runtime-resolver 0.2.0 → 0.3.0

package/index.d.ts

@@ -2,7 +2,6 @@ import { Context } from 'effect';
 import { DateTime } from 'effect';
 import { Effect } from 'effect';
 import type { EmptyCacheError } from 'semver-effect';
-import { Equals } from 'effect/Types';
 import type { InvalidRangeError } from 'semver-effect';
 import type { InvalidVersionError } from 'semver-effect';
 import { Layer } from 'effect';
@@ -12,6 +11,7 @@ import { Schema } from 'effect';
 import { SemVer } from 'semver-effect';
 import type { UnsatisfiedRangeError } from 'semver-effect';
 import { VersionCache } from 'semver-effect';
+import { VoidIfEmpty } from 'effect/Types';
 import { YieldableError } from 'effect/Cause';
 
 /**
@@ -42,27 +42,13 @@ import { YieldableError } from 'effect/Cause';
  *
  * @public
  */
-export declare class AuthenticationError extends AuthenticationErrorBase<{
+export declare class AuthenticationError extends AuthenticationError_base<{
     readonly method: "token" | "app";
     readonly message: string;
 }> {
 }
 
-/**
- * @internal
- * Exported for declaration bundling (api-extractor). When `export *` re-exports
- * a class whose `extends` expression is an inline call like
- * `Data.TaggedError(...)`, TypeScript emits an un-nameable `_base` symbol in
- * the declaration file. Splitting the base into a named export gives the
- * bundler a stable reference.
- *
- * @privateRemarks
- * This base constant must remain a named export so that api-extractor can
- * resolve the extends clause of {@link AuthenticationError} to a stable
- * declaration. Without it the bundled `.d.ts` would contain an anonymous
- * `_base` symbol that cannot be referenced by downstream consumers.
- */
-export declare const AuthenticationErrorBase: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & {
+declare const AuthenticationError_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<    { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
     readonly _tag: "AuthenticationError";
 } & Readonly<A>;
 
@@ -137,14 +123,14 @@ export declare const AutoDenoCacheLive: Layer.Layer<DenoReleaseCache, never, Den
 export declare const AutoNodeCacheLive: Layer.Layer<NodeReleaseCache, never, NodeVersionFetcher | NodeScheduleFetcher>;
 
 /**
- * A Bun release entry with a parsed {@link SemVer.SemVer} version and an
+ * A Bun release entry with a parsed {@link SemVer} version and an
  * Effect {@link DateTime.DateTime} publication date.
  *
  * `BunRelease` extends `Data.TaggedClass` so instances support structural
  * equality comparison and can be used safely inside Effect data structures.
  * Construct instances via the {@link BunRelease.fromInput} factory rather than
  * calling `new BunRelease(...)` directly, as the factory validates the version
- * string through `SemVer.fromString`.
+ * string through `SemVer.parse`.
  *
  * @see {@link BunReleaseCache}
  * @see {@link BunResolver}
@@ -169,14 +155,14 @@ export declare const AutoNodeCacheLive: Layer.Layer<NodeReleaseCache, never, Nod
  *
  * @public
  */
-export declare class BunRelease extends BunReleaseBase<{
-    readonly version: SemVer.SemVer;
+export declare class BunRelease extends BunRelease_base<{
+    readonly version: SemVer;
     readonly date: DateTime.DateTime;
 }> {
     /**
      * Create a {@link BunRelease} from lean string inputs.
      *
-     * Parses `input.version` via `SemVer.fromString` and constructs the
+     * Parses `input.version` via `SemVer.parse` and constructs the
      * publication date with `DateTime.unsafeMake`. Falls back to the current
      * timestamp when `input.date` is an empty string (rare in production data).
      *
@@ -187,46 +173,13 @@ export declare class BunRelease extends BunReleaseBase<{
     static fromInput(input: RuntimeReleaseInput): Effect.Effect<BunRelease, InvalidVersionError>;
 }
 
-/**
- * @internal
- *
- * Exported for declaration bundling (api-extractor). When `export *`
- * re-exports a class whose `extends` expression is an inline call like
- * `Data.TaggedClass(...)`, TypeScript emits an un-nameable `_base` symbol in
- * the declaration file. Splitting the base into a named export gives the
- * bundler a stable reference.
- *
- * @privateRemarks
- * This base constant must remain a named export so that api-extractor can
- * resolve the extends clause of {@link BunRelease} to a stable declaration.
- * Without it the bundled `.d.ts` would contain an anonymous `_base` symbol
- * that cannot be referenced by downstream consumers.
- */
-export declare const BunReleaseBase: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Readonly<A> & {
+declare const BunRelease_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<    { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Readonly<A> & {
     readonly _tag: "BunRelease";
 };
 
 /**
  * Specialisation of {@link RuntimeCache} for Bun release objects.
  *
- * @see {@link BunRelease}
- * @see {@link RuntimeCache}
- * @see {@link AutoBunCacheLive}
- * @see {@link FreshBunCacheLive}
- * @see {@link OfflineBunCacheLive}
- *
- * @public
- */
-export declare type BunReleaseCache = RuntimeCache<BunRelease>;
-
-/**
- * Service tag and companion object for {@link BunReleaseCache}.
- *
- * Acts as both the TypeScript service interface (via the type alias above) and
- * the Effect dependency tag used for dependency injection. Yield this tag
- * inside `Effect.gen` to access the cache implementation provided by one of
- * the cache layers.
- *
  * @example
  * ```typescript
  * import type { BunRelease } from "runtime-resolver";
@@ -242,13 +195,18 @@ export declare type BunReleaseCache = RuntimeCache<BunRelease>;
  * Effect.runPromise(program.pipe(Effect.provide(OfflineBunCacheLive)));
  * ```
  *
+ * @see {@link BunRelease}
+ * @see {@link RuntimeCache}
  * @see {@link AutoBunCacheLive}
  * @see {@link FreshBunCacheLive}
  * @see {@link OfflineBunCacheLive}
  *
  * @public
  */
-export declare const BunReleaseCache: Context.Tag<BunReleaseCache, BunReleaseCache>;
+export declare class BunReleaseCache extends BunReleaseCache_base {
+}
+
+declare const BunReleaseCache_base: Context.TagClass<BunReleaseCache, "runtime-resolver/BunReleaseCache", RuntimeCache<BunRelease>>;
 
 /**
  * Low-level layer that constructs the {@link BunReleaseCache} service backed by
@@ -269,40 +227,9 @@ export declare const BunReleaseCache: Context.Tag<BunReleaseCache, BunReleaseCac
 export declare const BunReleaseCacheLive: Layer.Layer<BunReleaseCache, never, VersionCache>;
 
 /**
- * Service interface for resolving Bun runtime versions against the cached
+ * Service for resolving Bun runtime versions against the cached
  * release index.
  *
- * @see {@link BunResolverLive}
- * @see {@link resolveBun}
- * @see {@link BunResolverOptions}
- * @see {@link ResolvedVersions}
- *
- * @public
- */
-export declare interface BunResolver {
-    /**
-     * Resolves Bun versions according to `options` and returns a
-     * {@link ResolvedVersions} object containing the matching version list,
-     * the latest version string, and the data source indicator.
-     *
-     * Fails with {@link BunResolverError} when no version can be resolved and
-     * no `defaultVersion` was provided.
-     *
-     * @param options - Optional resolution constraints.
-     *
-     * @see {@link BunResolverOptions}
-     */
-    readonly resolve: (options?: BunResolverOptions) => Effect.Effect<ResolvedVersions, BunResolverError>;
-}
-
-/**
- * Service tag and companion object for {@link BunResolver}.
- *
- * Acts as both the TypeScript service interface and the Effect dependency tag
- * used for dependency injection (companion object pattern). Yield this tag
- * inside `Effect.gen` to obtain the resolver implementation provided by
- * {@link BunResolverLive}.
- *
  * For a one-shot Promise-based API see {@link resolveBun}.
  *
  * @example
@@ -323,10 +250,35 @@ export declare interface BunResolver {
  *
  * @see {@link BunResolverLive}
  * @see {@link resolveBun}
+ * @see {@link BunResolverOptions}
+ * @see {@link ResolvedVersions}
  *
  * @public
  */
-export declare const BunResolver: Context.Tag<BunResolver, BunResolver>;
+export declare class BunResolver extends BunResolver_base {
+}
+
+declare const BunResolver_base: Context.TagClass<BunResolver, "runtime-resolver/BunResolver", {
+    /**
+     * Resolves Bun versions according to `options` and returns a
+     * {@link ResolvedVersions} object containing the matching version list,
+     * the latest version string, and the data source indicator.
+     *
+     * Fails with {@link BunResolverError} when no version can be resolved and
+     * no `defaultVersion` was provided.
+     *
+     * @param options - Optional resolution constraints.
+     *
+     * @see {@link BunResolverOptions}
+     */
+    readonly resolve: (options?: BunResolverOptions | undefined) => Effect.Effect<{
+        readonly source: "api" | "cache";
+        readonly versions: readonly string[];
+        readonly latest: string;
+        readonly lts?: string | undefined;
+        readonly default?: string | undefined;
+    }, VersionNotFoundError, never>;
+}>;
 
 /**
  * Union of all typed errors that {@link BunResolver.resolve} can fail with.
@@ -419,47 +371,13 @@ export declare interface BunResolverOptions {
 }
 
 /**
- * Service interface for fetching Bun release data from the GitHub API.
+ * Service for fetching Bun release data from the GitHub API.
  *
  * Retrieves both the parsed semver version list and the raw release input
  * records needed to populate a {@link BunReleaseCache}. The live
  * implementation queries the `oven-sh/bun` GitHub repository via
  * {@link GitHubClient}.
  *
- * @see {@link BunVersionFetcherLive}
- * @see {@link BunReleaseCache}
- * @see {@link AuthenticationError}
- * @see {@link NetworkError}
- * @see {@link ParseError}
- * @see {@link RateLimitError}
- *
- * @public
- */
-export declare interface BunVersionFetcher {
-    /**
-     * Fetches all available Bun releases from the GitHub API and returns both
-     * the parsed semver version objects and the raw release input records.
-     *
-     * Fails with:
-     * - {@link AuthenticationError} — missing or invalid GitHub credentials.
-     * - {@link NetworkError} — the upstream request could not be completed.
-     * - {@link ParseError} — the response payload could not be decoded.
-     * - {@link RateLimitError} — the GitHub API rate limit was exceeded.
-     */
-    readonly fetch: () => Effect.Effect<{
-        readonly versions: ReadonlyArray<SemVer.SemVer>;
-        readonly inputs: ReadonlyArray<RuntimeReleaseInput>;
-    }, AuthenticationError | NetworkError | ParseError | RateLimitError>;
-}
-
-/**
- * Service tag and companion object for {@link BunVersionFetcher}.
- *
- * Acts as both the TypeScript service interface and the Effect dependency tag
- * used for dependency injection (companion object pattern). Yield this tag
- * inside `Effect.gen` to access the fetcher implementation provided by
- * {@link BunVersionFetcherLive}.
- *
  * @example
  * ```typescript
  * import type { RuntimeReleaseInput } from "runtime-resolver";
@@ -478,10 +396,36 @@ export declare interface BunVersionFetcher {
  * ```
  *
  * @see {@link BunVersionFetcherLive}
+ * @see {@link BunReleaseCache}
+ * @see {@link AuthenticationError}
+ * @see {@link NetworkError}
+ * @see {@link ParseError}
+ * @see {@link RateLimitError}
  *
  * @public
  */
-export declare const BunVersionFetcher: Context.Tag<BunVersionFetcher, BunVersionFetcher>;
+export declare class BunVersionFetcher extends BunVersionFetcher_base {
+}
+
+declare const BunVersionFetcher_base: Context.TagClass<BunVersionFetcher, "runtime-resolver/BunVersionFetcher", {
+    /**
+     * Fetches all available Bun releases from the GitHub API and returns both
+     * the parsed semver version objects and the raw release input records.
+     *
+     * Fails with:
+     * - {@link AuthenticationError} — missing or invalid GitHub credentials.
+     * - {@link NetworkError} — the upstream request could not be completed.
+     * - {@link ParseError} — the response payload could not be decoded.
+     * - {@link RateLimitError} — the GitHub API rate limit was exceeded.
+     */
+    readonly fetch: () => Effect.Effect<{
+        readonly versions: readonly SemVer[];
+        readonly inputs: readonly {
+            readonly version: string;
+            readonly date: string;
+        }[];
+    }, AuthenticationError | NetworkError | ParseError | RateLimitError, never>;
+}>;
 
 /**
  * Provides the {@link BunVersionFetcher} service using the live GitHub API.
@@ -527,23 +471,13 @@ export declare const BunVersionFetcherLive: Layer.Layer<BunVersionFetcher, never
  *
  * @public
  */
-export declare class CacheError extends CacheErrorBase<{
+export declare class CacheError extends CacheError_base<{
     readonly operation: "read" | "write";
     readonly message: string;
 }> {
 }
 
-/**
- * @internal
- * Exported for declaration bundling — see AuthenticationError.ts for details.
- *
- * @privateRemarks
- * This base constant must remain a named export so that api-extractor can
- * resolve the extends clause of {@link CacheError} to a stable declaration.
- * Without it the bundled `.d.ts` would contain an anonymous `_base` symbol
- * that cannot be referenced by downstream consumers.
- */
-export declare const CacheErrorBase: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & {
+declare const CacheError_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<    { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
     readonly _tag: "CacheError";
 } & Readonly<A>;
 
@@ -579,14 +513,14 @@ export declare const CacheErrorBase: new <A extends Record<string, any> = {}>(ar
 export declare const createRuntimeCache: <R extends RuntimeRelease>() => Effect.Effect<RuntimeCache<R>, never, VersionCache>;
 
 /**
- * A Deno release entry with a parsed {@link SemVer.SemVer} version and an
+ * A Deno release entry with a parsed {@link SemVer} version and an
  * Effect {@link DateTime.DateTime} publication date.
  *
  * `DenoRelease` extends `Data.TaggedClass` so instances support structural
  * equality comparison and can be used safely inside Effect data structures.
  * Construct instances via the {@link DenoRelease.fromInput} factory rather than
  * calling `new DenoRelease(...)` directly, as the factory validates the version
- * string through `SemVer.fromString`.
+ * string through `SemVer.parse`.
  *
  * @see {@link DenoReleaseCache}
  * @see {@link DenoResolver}
@@ -611,14 +545,14 @@ export declare const createRuntimeCache: <R extends RuntimeRelease>() => Effect.
  *
  * @public
  */
-export declare class DenoRelease extends DenoReleaseBase<{
-    readonly version: SemVer.SemVer;
+export declare class DenoRelease extends DenoRelease_base<{
+    readonly version: SemVer;
     readonly date: DateTime.DateTime;
 }> {
     /**
      * Create a {@link DenoRelease} from lean string inputs.
      *
-     * Parses `input.version` via `SemVer.fromString` and constructs the
+     * Parses `input.version` via `SemVer.parse` and constructs the
      * publication date with `DateTime.unsafeMake`. Falls back to the current
      * timestamp when `input.date` is an empty string (rare in production data).
      *
@@ -629,46 +563,13 @@ export declare class DenoRelease extends DenoReleaseBase<{
     static fromInput(input: RuntimeReleaseInput): Effect.Effect<DenoRelease, InvalidVersionError>;
 }
 
-/**
- * @internal
- *
- * Exported for declaration bundling (api-extractor). When `export *`
- * re-exports a class whose `extends` expression is an inline call like
- * `Data.TaggedClass(...)`, TypeScript emits an un-nameable `_base` symbol in
- * the declaration file. Splitting the base into a named export gives the
- * bundler a stable reference.
- *
- * @privateRemarks
- * This base constant must remain a named export so that api-extractor can
- * resolve the extends clause of {@link DenoRelease} to a stable declaration.
- * Without it the bundled `.d.ts` would contain an anonymous `_base` symbol
- * that cannot be referenced by downstream consumers.
- */
-export declare const DenoReleaseBase: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Readonly<A> & {
+declare const DenoRelease_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<    { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Readonly<A> & {
     readonly _tag: "DenoRelease";
 };
 
 /**
  * Specialisation of {@link RuntimeCache} for Deno release objects.
  *
- * @see {@link DenoRelease}
- * @see {@link RuntimeCache}
- * @see {@link AutoDenoCacheLive}
- * @see {@link FreshDenoCacheLive}
- * @see {@link OfflineDenoCacheLive}
- *
- * @public
- */
-export declare type DenoReleaseCache = RuntimeCache<DenoRelease>;
-
-/**
- * Service tag and companion object for {@link DenoReleaseCache}.
- *
- * Acts as both the TypeScript service interface (via the type alias above) and
- * the Effect dependency tag used for dependency injection. Yield this tag
- * inside `Effect.gen` to access the cache implementation provided by one of
- * the cache layers.
- *
  * @example
  * ```typescript
  * import type { DenoRelease } from "runtime-resolver";
@@ -684,13 +585,18 @@ export declare type DenoReleaseCache = RuntimeCache<DenoRelease>;
  * Effect.runPromise(program.pipe(Effect.provide(OfflineDenoCacheLive)));
  * ```
  *
+ * @see {@link DenoRelease}
+ * @see {@link RuntimeCache}
  * @see {@link AutoDenoCacheLive}
  * @see {@link FreshDenoCacheLive}
  * @see {@link OfflineDenoCacheLive}
  *
  * @public
  */
-export declare const DenoReleaseCache: Context.Tag<DenoReleaseCache, DenoReleaseCache>;
+export declare class DenoReleaseCache extends DenoReleaseCache_base {
+}
+
+declare const DenoReleaseCache_base: Context.TagClass<DenoReleaseCache, "runtime-resolver/DenoReleaseCache", RuntimeCache<DenoRelease>>;
 
 /**
  * Low-level layer that constructs the {@link DenoReleaseCache} service backed by
@@ -711,40 +617,9 @@ export declare const DenoReleaseCache: Context.Tag<DenoReleaseCache, DenoRelease
 export declare const DenoReleaseCacheLive: Layer.Layer<DenoReleaseCache, never, VersionCache>;
 
 /**
- * Service interface for resolving Deno runtime versions against the cached
+ * Service for resolving Deno runtime versions against the cached
  * release index.
  *
- * @see {@link DenoResolverLive}
- * @see {@link resolveDeno}
- * @see {@link DenoResolverOptions}
- * @see {@link ResolvedVersions}
- *
- * @public
- */
-export declare interface DenoResolver {
-    /**
-     * Resolves Deno versions according to `options` and returns a
-     * {@link ResolvedVersions} object containing the matching version list,
-     * the latest version string, and the data source indicator.
-     *
-     * Fails with {@link DenoResolverError} when no version can be resolved and
-     * no `defaultVersion` was provided.
-     *
-     * @param options - Optional resolution constraints.
-     *
-     * @see {@link DenoResolverOptions}
-     */
-    readonly resolve: (options?: DenoResolverOptions) => Effect.Effect<ResolvedVersions, DenoResolverError>;
-}
-
-/**
- * Service tag and companion object for {@link DenoResolver}.
- *
- * Acts as both the TypeScript service interface and the Effect dependency tag
- * used for dependency injection (companion object pattern). Yield this tag
- * inside `Effect.gen` to obtain the resolver implementation provided by
- * {@link DenoResolverLive}.
- *
  * For a one-shot Promise-based API see {@link resolveDeno}.
  *
  * @example
@@ -765,10 +640,35 @@ export declare interface DenoResolver {
  *
  * @see {@link DenoResolverLive}
  * @see {@link resolveDeno}
+ * @see {@link DenoResolverOptions}
+ * @see {@link ResolvedVersions}
  *
  * @public
  */
-export declare const DenoResolver: Context.Tag<DenoResolver, DenoResolver>;
+export declare class DenoResolver extends DenoResolver_base {
+}
+
+declare const DenoResolver_base: Context.TagClass<DenoResolver, "runtime-resolver/DenoResolver", {
+    /**
+     * Resolves Deno versions according to `options` and returns a
+     * {@link ResolvedVersions} object containing the matching version list,
+     * the latest version string, and the data source indicator.
+     *
+     * Fails with {@link DenoResolverError} when no version can be resolved and
+     * no `defaultVersion` was provided.
+     *
+     * @param options - Optional resolution constraints.
+     *
+     * @see {@link DenoResolverOptions}
+     */
+    readonly resolve: (options?: DenoResolverOptions | undefined) => Effect.Effect<{
+        readonly source: "api" | "cache";
+        readonly versions: readonly string[];
+        readonly latest: string;
+        readonly lts?: string | undefined;
+        readonly default?: string | undefined;
+    }, VersionNotFoundError, never>;
+}>;
 
 /**
  * Union of all typed errors that {@link DenoResolver.resolve} can fail with.
@@ -860,47 +760,13 @@ export declare interface DenoResolverOptions {
 }
 
 /**
- * Service interface for fetching Deno release data from the GitHub API.
+ * Service for fetching Deno release data from the GitHub API.
  *
  * Retrieves both the parsed semver version list and the raw release input
  * records needed to populate a {@link DenoReleaseCache}. The live
  * implementation queries the `denoland/deno` GitHub repository via
  * {@link GitHubClient}.
  *
- * @see {@link DenoVersionFetcherLive}
- * @see {@link DenoReleaseCache}
- * @see {@link AuthenticationError}
- * @see {@link NetworkError}
- * @see {@link ParseError}
- * @see {@link RateLimitError}
- *
- * @public
- */
-export declare interface DenoVersionFetcher {
-    /**
-     * Fetches all available Deno releases from the GitHub API and returns both
-     * the parsed semver version objects and the raw release input records.
-     *
-     * Fails with:
-     * - {@link AuthenticationError} — missing or invalid GitHub credentials.
-     * - {@link NetworkError} — the upstream request could not be completed.
-     * - {@link ParseError} — the response payload could not be decoded.
-     * - {@link RateLimitError} — the GitHub API rate limit was exceeded.
-     */
-    readonly fetch: () => Effect.Effect<{
-        readonly versions: ReadonlyArray<SemVer.SemVer>;
-        readonly inputs: ReadonlyArray<RuntimeReleaseInput>;
-    }, AuthenticationError | NetworkError | ParseError | RateLimitError>;
-}
-
-/**
- * Service tag and companion object for {@link DenoVersionFetcher}.
- *
- * Acts as both the TypeScript service interface and the Effect dependency tag
- * used for dependency injection (companion object pattern). Yield this tag
- * inside `Effect.gen` to access the fetcher implementation provided by
- * {@link DenoVersionFetcherLive}.
- *
  * @example
  * ```typescript
  * import type { RuntimeReleaseInput } from "runtime-resolver";
@@ -919,10 +785,36 @@ export declare interface DenoVersionFetcher {
  * ```
  *
  * @see {@link DenoVersionFetcherLive}
+ * @see {@link DenoReleaseCache}
+ * @see {@link AuthenticationError}
+ * @see {@link NetworkError}
+ * @see {@link ParseError}
+ * @see {@link RateLimitError}
  *
  * @public
  */
-export declare const DenoVersionFetcher: Context.Tag<DenoVersionFetcher, DenoVersionFetcher>;
+export declare class DenoVersionFetcher extends DenoVersionFetcher_base {
+}
+
+declare const DenoVersionFetcher_base: Context.TagClass<DenoVersionFetcher, "runtime-resolver/DenoVersionFetcher", {
+    /**
+     * Fetches all available Deno releases from the GitHub API and returns both
+     * the parsed semver version objects and the raw release input records.
+     *
+     * Fails with:
+     * - {@link AuthenticationError} — missing or invalid GitHub credentials.
+     * - {@link NetworkError} — the upstream request could not be completed.
+     * - {@link ParseError} — the response payload could not be decoded.
+     * - {@link RateLimitError} — the GitHub API rate limit was exceeded.
+     */
+    readonly fetch: () => Effect.Effect<{
+        readonly versions: readonly SemVer[];
+        readonly inputs: readonly {
+            readonly version: string;
+            readonly date: string;
+        }[];
+    }, AuthenticationError | NetworkError | ParseError | RateLimitError, never>;
+}>;
 
 /**
  * Provides the {@link DenoVersionFetcher} service using the live GitHub API.
@@ -1022,23 +914,13 @@ export declare const FreshDenoCacheLive: Layer.Layer<DenoReleaseCache, Freshness
  *
  * @public
  */
-export declare class FreshnessError extends FreshnessErrorBase<{
+export declare class FreshnessError extends FreshnessError_base<{
     readonly strategy: "auto" | "api" | "cache";
     readonly message: string;
 }> {
 }
 
-/**
- * @internal
- * Exported for declaration bundling — see AuthenticationError.ts for details.
- *
- * @privateRemarks
- * This base constant must remain a named export so that api-extractor can
- * resolve the extends clause of {@link FreshnessError} to a stable declaration.
- * Without it the bundled `.d.ts` would contain an anonymous `_base` symbol
- * that cannot be referenced by downstream consumers.
- */
-export declare const FreshnessErrorBase: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & {
+declare const FreshnessError_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<    { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
     readonly _tag: "FreshnessError";
 } & Readonly<A>;
 
@@ -1142,7 +1024,7 @@ export declare interface GitHubAppAuthConfig {
 export declare const GitHubAutoAuth: Layer.Layer<OctokitInstance, AuthenticationError>;
 
 /**
- * Service interface for GitHub REST API operations used by the version
+ * Service for GitHub REST API operations used by the version
  * fetcher services.
  *
  * Abstracts over pagination and authentication so that higher-level services
@@ -1151,13 +1033,33 @@ export declare const GitHubAutoAuth: Layer.Layer<OctokitInstance, Authentication
  * transport. The live implementation is provided by {@link GitHubClientLive}
  * and requires an {@link OctokitInstance} in its dependency graph.
  *
+ * @example
+ * ```typescript
+ * import type { GitHubTag } from "runtime-resolver";
+ * import { GitHubClient, GitHubClientLive, GitHubAutoAuth } from "runtime-resolver";
+ * import { Effect } from "effect";
+ *
+ * const program = Effect.gen(function* () {
+ * 	const client = yield* GitHubClient;
+ * 	const tags = yield* client.listTags("oven-sh", "bun", { perPage: 100 });
+ * 	console.log(`Found ${tags.length} tags`);
+ * });
+ *
+ * Effect.runPromise(
+ * 	program.pipe(Effect.provide(GitHubClientLive), Effect.provide(GitHubAutoAuth)),
+ * );
+ * ```
+ *
  * @see {@link GitHubClientLive}
  * @see {@link OctokitInstance}
  * @see {@link ListOptions}
  *
  * @public
  */
-export declare interface GitHubClient {
+export declare class GitHubClient extends GitHubClient_base {
+}
+
+declare const GitHubClient_base: Context.TagClass<GitHubClient, "runtime-resolver/GitHubClient", {
     /**
      * Lists all git tags for the given repository, automatically paginating
      * through results according to `options`.
@@ -1172,7 +1074,16 @@ export declare interface GitHubClient {
      * @param repo - Repository name (e.g. `"bun"`).
      * @param options - Optional pagination controls.
      */
-    readonly listTags: (owner: string, repo: string, options?: ListOptions) => Effect.Effect<ReadonlyArray<GitHubTag>, AuthenticationError | NetworkError | RateLimitError | ParseError>;
+    readonly listTags: (owner: string, repo: string, options?: ListOptions | undefined) => Effect.Effect<readonly {
+        readonly name: string;
+        readonly zipball_url: string;
+        readonly tarball_url: string;
+        readonly commit: {
+            readonly sha: string;
+            readonly url: string;
+        };
+        readonly node_id: string;
+    }[], AuthenticationError | NetworkError | ParseError | RateLimitError, never>;
     /**
      * Lists all GitHub Releases for the given repository, automatically
      * paginating through results according to `options`.
@@ -1187,7 +1098,13 @@ export declare interface GitHubClient {
      * @param repo - Repository name (e.g. `"deno"`).
      * @param options - Optional pagination controls.
      */
-    readonly listReleases: (owner: string, repo: string, options?: ListOptions) => Effect.Effect<ReadonlyArray<GitHubRelease>, AuthenticationError | NetworkError | RateLimitError | ParseError>;
+    readonly listReleases: (owner: string, repo: string, options?: ListOptions | undefined) => Effect.Effect<readonly {
+        readonly tag_name: string;
+        readonly name: string | null;
+        readonly draft: boolean;
+        readonly prerelease: boolean;
+        readonly published_at: string | null;
+    }[], AuthenticationError | NetworkError | ParseError | RateLimitError, never>;
     /**
      * Fetches arbitrary JSON from `url` and decodes it with the provided
      * schema, returning the typed result.
@@ -1205,41 +1122,9 @@ export declare interface GitHubClient {
      * Effect Schema's `decodeUnknown`.
      */
     readonly getJson: <A>(url: string, schema: {
-        readonly decode: (input: unknown) => Effect.Effect<A, ParseError>;
-    }) => Effect.Effect<A, NetworkError | ParseError>;
-}
-
-/**
- * Service tag and companion object for {@link GitHubClient}.
- *
- * Acts as both the TypeScript service interface and the Effect dependency tag
- * used for dependency injection (companion object pattern). Yield this tag
- * inside `Effect.gen` to access the client implementation provided by
- * {@link GitHubClientLive}.
- *
- * @example
- * ```typescript
- * import type { GitHubTag } from "runtime-resolver";
- * import { GitHubClient, GitHubClientLive, GitHubAutoAuth } from "runtime-resolver";
- * import { Effect } from "effect";
- *
- * const program = Effect.gen(function* () {
- * 	const client = yield* GitHubClient;
- * 	const tags = yield* client.listTags("oven-sh", "bun", { perPage: 100 });
- * 	console.log(`Found ${tags.length} tags`);
- * });
- *
- * Effect.runPromise(
- * 	program.pipe(Effect.provide(GitHubClientLive), Effect.provide(GitHubAutoAuth)),
- * );
- * ```
- *
- * @see {@link GitHubClientLive}
- * @see {@link OctokitInstance}
- *
- * @public
- */
-export declare const GitHubClient: Context.Tag<GitHubClient, GitHubClient>;
+        readonly decode: (input: unknown) => Effect.Effect<A, ParseError, never>;
+    }) => Effect.Effect<A, NetworkError | ParseError, never>;
+}>;
 
 /**
  * Provides the {@link GitHubClient} service backed by an {@link OctokitInstance}.
@@ -1408,24 +1293,14 @@ export declare type Increments = typeof Increments.Type;
  *
  * @public
  */
-export declare class InvalidInputError extends InvalidInputErrorBase<{
+export declare class InvalidInputError extends InvalidInputError_base<{
     readonly field: string;
     readonly value: string;
     readonly message: string;
 }> {
 }
 
-/**
- * @internal
- * Exported for declaration bundling — see AuthenticationError.ts for details.
- *
- * @privateRemarks
- * This base constant must remain a named export so that api-extractor can
- * resolve the extends clause of {@link InvalidInputError} to a stable
- * declaration. Without it the bundled `.d.ts` would contain an anonymous
- * `_base` symbol that cannot be referenced by downstream consumers.
- */
-export declare const InvalidInputErrorBase: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & {
+declare const InvalidInputError_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<    { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
     readonly _tag: "InvalidInputError";
 } & Readonly<A>;
 
@@ -1476,24 +1351,14 @@ export declare interface ListOptions {
  *
  * @public
  */
-export declare class NetworkError extends NetworkErrorBase<{
+export declare class NetworkError extends NetworkError_base<{
     readonly url: string;
     readonly status?: number;
     readonly message: string;
 }> {
 }
 
-/**
- * @internal
- * Exported for declaration bundling — see AuthenticationError.ts for details.
- *
- * @privateRemarks
- * This base constant must remain a named export so that api-extractor can
- * resolve the extends clause of {@link NetworkError} to a stable declaration.
- * Without it the bundled `.d.ts` would contain an anonymous `_base` symbol
- * that cannot be referenced by downstream consumers.
- */
-export declare const NetworkErrorBase: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & {
+declare const NetworkError_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<    { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
     readonly _tag: "NetworkError";
 } & Readonly<A>;
 
@@ -1570,12 +1435,12 @@ export declare type NodePhase = typeof NodePhase.Type;
  * @public
  */
 export declare class NodeRelease {
-    readonly version: SemVer.SemVer;
-    readonly npm: SemVer.SemVer;
+    readonly version: SemVer;
+    readonly npm: SemVer;
     readonly date: DateTime.DateTime;
     readonly scheduleRef: Ref.Ref<NodeSchedule>;
     readonly _tag: "NodeRelease";
-    constructor(version: SemVer.SemVer, npm: SemVer.SemVer, date: DateTime.DateTime, scheduleRef: Ref.Ref<NodeSchedule>);
+    constructor(version: SemVer, npm: SemVer, date: DateTime.DateTime, scheduleRef: Ref.Ref<NodeSchedule>);
     /**
      * Determine this release's lifecycle phase at the given point in time.
      *
@@ -1601,7 +1466,7 @@ export declare class NodeRelease {
     /**
      * Create a {@link NodeRelease} from lean string inputs.
      *
-     * Parses `input.version` and `input.npm` via `SemVer.fromString` and
+     * Parses `input.version` and `input.npm` via `SemVer.parse` and
      * constructs the publication date with `DateTime.unsafeMake`.
      *
      * @param input - A {@link NodeReleaseInput} object with raw string fields.
@@ -1617,16 +1482,9 @@ export declare class NodeRelease {
  * additional operations for lifecycle schedule data and LTS / current
  * release filtering.
  *
- * Unlike the Bun and Deno equivalents this interface is not a plain type alias
+ * Unlike the Bun and Deno equivalents this service is not a plain type alias
  * — it adds four Node-specific methods on top of the generic cache contract.
  *
- * @see {@link NodeRelease}
- * @see {@link NodeScheduleData}
- * @see {@link RuntimeCache}
- * @see {@link AutoNodeCacheLive}
- * @see {@link FreshNodeCacheLive}
- * @see {@link OfflineNodeCacheLive}
- *
  * @example
  * ```typescript
  * import type { NodeRelease } from "runtime-resolver";
@@ -1644,9 +1502,19 @@ export declare class NodeRelease {
  * Effect.runPromise(program.pipe(Effect.provide(OfflineNodeCacheLive)));
  * ```
  *
+ * @see {@link NodeRelease}
+ * @see {@link NodeScheduleData}
+ * @see {@link RuntimeCache}
+ * @see {@link AutoNodeCacheLive}
+ * @see {@link FreshNodeCacheLive}
+ * @see {@link OfflineNodeCacheLive}
+ *
  * @public
  */
-export declare interface NodeReleaseCache extends RuntimeCache<NodeRelease> {
+export declare class NodeReleaseCache extends NodeReleaseCache_base {
+}
+
+declare const NodeReleaseCache_base: Context.TagClass<NodeReleaseCache, "runtime-resolver/NodeReleaseCache", RuntimeCache<NodeRelease> & {
     /**
      * Merges Node.js release-schedule data into the cache, updating lifecycle
      * phase information (LTS dates, end-of-life dates, etc.) for every major
@@ -1657,7 +1525,7 @@ export declare interface NodeReleaseCache extends RuntimeCache<NodeRelease> {
      *
      * @see {@link NodeScheduleData}
      */
-    readonly updateSchedule: (data: NodeScheduleData) => Effect.Effect<void>;
+    readonly updateSchedule: (data: NodeScheduleData) => Effect.Effect<void, never, never>;
     /**
      * Populates the cache from raw {@link NodeReleaseInput} records (as
      * returned by the Node.js release index JSON) rather than from already-
@@ -1670,7 +1538,11 @@ export declare interface NodeReleaseCache extends RuntimeCache<NodeRelease> {
      *
      * @see {@link NodeReleaseInput}
      */
-    readonly loadFromInputs: (inputs: ReadonlyArray<NodeReleaseInput>) => Effect.Effect<void>;
+    readonly loadFromInputs: (inputs: readonly {
+        readonly version: string;
+        readonly npm: string;
+        readonly date: string;
+    }[]) => Effect.Effect<void, never, never>;
     /**
      * Returns all cached releases whose lifecycle phase is `"active-lts"` or
      * `"maintenance-lts"` as of the given point in time.
@@ -1681,7 +1553,7 @@ export declare interface NodeReleaseCache extends RuntimeCache<NodeRelease> {
      *
      * @see {@link NodeRelease}
      */
-    readonly ltsReleases: (now?: DateTime.DateTime) => Effect.Effect<ReadonlyArray<NodeRelease>>;
+    readonly ltsReleases: (now?: DateTime.DateTime | undefined) => Effect.Effect<readonly NodeRelease[], never, never>;
     /**
      * Returns all cached releases whose lifecycle phase is `"current"` as of
      * the given point in time.
@@ -1692,24 +1564,8 @@ export declare interface NodeReleaseCache extends RuntimeCache<NodeRelease> {
      *
      * @see {@link NodeRelease}
      */
-    readonly currentReleases: (now?: DateTime.DateTime) => Effect.Effect<ReadonlyArray<NodeRelease>>;
-}
-
-/**
- * Service tag and companion object for {@link NodeReleaseCache}.
- *
- * Acts as both the TypeScript service interface and the Effect dependency tag
- * used for dependency injection (companion object pattern). Yield this tag
- * inside `Effect.gen` to access the cache implementation supplied by one of
- * the Node cache layers.
- *
- * @see {@link AutoNodeCacheLive}
- * @see {@link FreshNodeCacheLive}
- * @see {@link OfflineNodeCacheLive}
- *
- * @public
- */
-export declare const NodeReleaseCache: Context.Tag<NodeReleaseCache, NodeReleaseCache>;
+    readonly currentReleases: (now?: DateTime.DateTime | undefined) => Effect.Effect<readonly NodeRelease[], never, never>;
+}>;
 
 /**
  * Low-level layer that constructs the {@link NodeReleaseCache} service backed by
@@ -1740,7 +1596,7 @@ export declare const NodeReleaseCacheLive: Layer.Layer<NodeReleaseCache, never,
  * bundled default data files and the Node.js dist API response.
  *
  * The `version` and `npm` fields are raw version strings validated by
- * `SemVer.fromString`; `date` is a date string accepted by
+ * `SemVer.parse`; `date` is a date string accepted by
  * `DateTime.unsafeMake`.
  *
  * @see {@link NodeRelease.fromInput}
@@ -1764,45 +1620,13 @@ export declare const NodeReleaseInput: Schema.Struct<{
 export declare type NodeReleaseInput = typeof NodeReleaseInput.Type;
 
 /**
- * Service interface for resolving Node.js runtime versions against the cached
+ * Service for resolving Node.js runtime versions against the cached
  * release index.
  *
  * Unlike {@link BunResolver} and {@link DenoResolver}, this service is
  * lifecycle-aware: results can be filtered by {@link NodePhase} and evaluated
  * against a specific reference date.
  *
- * @see {@link NodeResolverLive}
- * @see {@link resolveNode}
- * @see {@link NodeResolverOptions}
- * @see {@link ResolvedVersions}
- *
- * @public
- */
-export declare interface NodeResolver {
-    /**
-     * Resolves Node.js versions according to `options` and returns a
-     * {@link ResolvedVersions} object containing the matching version list,
-     * the latest version string, optional LTS version string, and the data
-     * source indicator.
-     *
-     * Fails with {@link NodeResolverError} when no version can be resolved and
-     * no `defaultVersion` was provided.
-     *
-     * @param options - Optional resolution constraints.
-     *
-     * @see {@link NodeResolverOptions}
-     */
-    readonly resolve: (options?: NodeResolverOptions) => Effect.Effect<ResolvedVersions, NodeResolverError>;
-}
-
-/**
- * Service tag and companion object for {@link NodeResolver}.
- *
- * Acts as both the TypeScript service interface and the Effect dependency tag
- * used for dependency injection (companion object pattern). Yield this tag
- * inside `Effect.gen` to obtain the resolver implementation provided by
- * {@link NodeResolverLive}.
- *
  * For a one-shot Promise-based API see {@link resolveNode}.
  *
  * @example
@@ -1827,10 +1651,36 @@ export declare interface NodeResolver {
  *
  * @see {@link NodeResolverLive}
  * @see {@link resolveNode}
+ * @see {@link NodeResolverOptions}
+ * @see {@link ResolvedVersions}
  *
  * @public
  */
-export declare const NodeResolver: Context.Tag<NodeResolver, NodeResolver>;
+export declare class NodeResolver extends NodeResolver_base {
+}
+
+declare const NodeResolver_base: Context.TagClass<NodeResolver, "runtime-resolver/NodeResolver", {
+    /**
+     * Resolves Node.js versions according to `options` and returns a
+     * {@link ResolvedVersions} object containing the matching version list,
+     * the latest version string, optional LTS version string, and the data
+     * source indicator.
+     *
+     * Fails with {@link NodeResolverError} when no version can be resolved and
+     * no `defaultVersion` was provided.
+     *
+     * @param options - Optional resolution constraints.
+     *
+     * @see {@link NodeResolverOptions}
+     */
+    readonly resolve: (options?: NodeResolverOptions | undefined) => Effect.Effect<{
+        readonly source: "api" | "cache";
+        readonly versions: readonly string[];
+        readonly latest: string;
+        readonly lts?: string | undefined;
+        readonly default?: string | undefined;
+    }, VersionNotFoundError, never>;
+}>;
 
 /**
  * Union of all typed errors that {@link NodeResolver.resolve} can fail with.
@@ -1998,7 +1848,7 @@ export declare interface NodeResolverOptions {
  *
  * @public
  */
-export declare class NodeSchedule extends NodeScheduleBase<{
+export declare class NodeSchedule extends NodeSchedule_base<{
     readonly entries: ReadonlyArray<NodeScheduleEntry>;
 }> {
     /**
@@ -2032,22 +1882,7 @@ export declare class NodeSchedule extends NodeScheduleBase<{
     entryFor(major: number): Option.Option<NodeScheduleEntry>;
 }
 
-/**
- * @internal
- *
- * Exported for declaration bundling (api-extractor). When `export *`
- * re-exports a class whose `extends` expression is an inline call like
- * `Data.TaggedClass(...)`, TypeScript emits an un-nameable `_base` symbol in
- * the declaration file. Splitting the base into a named export gives the
- * bundler a stable reference.
- *
- * @privateRemarks
- * This base constant must remain a named export so that api-extractor can
- * resolve the extends clause of {@link NodeSchedule} to a stable declaration.
- * Without it the bundled `.d.ts` would contain an anonymous `_base` symbol
- * that cannot be referenced by downstream consumers.
- */
-export declare const NodeScheduleBase: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Readonly<A> & {
+declare const NodeSchedule_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<    { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Readonly<A> & {
     readonly _tag: "NodeSchedule";
 };
 
@@ -2094,41 +1929,13 @@ export declare interface NodeScheduleEntry {
 }
 
 /**
- * Service interface for fetching the official Node.js release schedule.
+ * Service for fetching the official Node.js release schedule.
  *
  * The schedule maps each major release line to its LTS start date and
  * end-of-life date, and is used by {@link NodeReleaseCache} to assign
  * lifecycle phases to individual releases. The live implementation fetches
  * from the `nodejs/Release` GitHub repository via a plain HTTP request.
  *
- * @see {@link NodeScheduleFetcherLive}
- * @see {@link NodeReleaseCache}
- * @see {@link NodeScheduleData}
- * @see {@link NetworkError}
- * @see {@link ParseError}
- *
- * @public
- */
-export declare interface NodeScheduleFetcher {
-    /**
-     * Fetches and decodes the Node.js release schedule JSON, returning a
-     * typed {@link NodeScheduleData} map keyed by major release line.
-     *
-     * Fails with:
-     * - {@link NetworkError} — the upstream request could not be completed.
-     * - {@link ParseError} — the response payload could not be decoded.
-     */
-    readonly fetch: () => Effect.Effect<NodeScheduleData, NetworkError | ParseError>;
-}
-
-/**
- * Service tag and companion object for {@link NodeScheduleFetcher}.
- *
- * Acts as both the TypeScript service interface and the Effect dependency tag
- * used for dependency injection (companion object pattern). Yield this tag
- * inside `Effect.gen` to access the fetcher implementation provided by
- * {@link NodeScheduleFetcherLive}.
- *
  * @example
  * ```typescript
  * import type { NodeScheduleData } from "runtime-resolver";
@@ -2145,10 +1952,27 @@ export declare interface NodeScheduleFetcher {
  * ```
  *
  * @see {@link NodeScheduleFetcherLive}
+ * @see {@link NodeReleaseCache}
+ * @see {@link NodeScheduleData}
+ * @see {@link NetworkError}
+ * @see {@link ParseError}
  *
  * @public
  */
-export declare const NodeScheduleFetcher: Context.Tag<NodeScheduleFetcher, NodeScheduleFetcher>;
+export declare class NodeScheduleFetcher extends NodeScheduleFetcher_base {
+}
+
+declare const NodeScheduleFetcher_base: Context.TagClass<NodeScheduleFetcher, "runtime-resolver/NodeScheduleFetcher", {
+    /**
+     * Fetches and decodes the Node.js release schedule JSON, returning a
+     * typed {@link NodeScheduleData} map keyed by major release line.
+     *
+     * Fails with:
+     * - {@link NetworkError} — the upstream request could not be completed.
+     * - {@link ParseError} — the response payload could not be decoded.
+     */
+    readonly fetch: () => Effect.Effect<NodeScheduleData, NetworkError | ParseError, never>;
+}>;
 
 /**
  * Provides the {@link NodeScheduleFetcher} service using the live Node.js release schedule.
@@ -2171,7 +1995,7 @@ export declare const NodeScheduleFetcher: Context.Tag<NodeScheduleFetcher, NodeS
 export declare const NodeScheduleFetcherLive: Layer.Layer<NodeScheduleFetcher, never, GitHubClient>;
 
 /**
- * Service interface for fetching Node.js release data from the official
+ * Service for fetching Node.js release data from the official
  * Node.js distribution index.
  *
  * Retrieves both the parsed semver version list and the raw
@@ -2180,37 +2004,6 @@ export declare const NodeScheduleFetcherLive: Layer.Layer<NodeScheduleFetcher, n
  * `https://nodejs.org/dist/index.json` via a plain HTTP request — no GitHub
  * credentials are required.
  *
- * @see {@link NodeVersionFetcherLive}
- * @see {@link NodeReleaseCache}
- * @see {@link NetworkError}
- * @see {@link ParseError}
- *
- * @public
- */
-export declare interface NodeVersionFetcher {
-    /**
-     * Fetches all available Node.js releases from the distribution index and
-     * returns both the parsed semver version objects and the raw release input
-     * records.
-     *
-     * Fails with:
-     * - {@link NetworkError} — the upstream request could not be completed.
-     * - {@link ParseError} — the response payload could not be decoded.
-     */
-    readonly fetch: () => Effect.Effect<{
-        readonly versions: ReadonlyArray<SemVer.SemVer>;
-        readonly inputs: ReadonlyArray<NodeReleaseInput>;
-    }, NetworkError | ParseError>;
-}
-
-/**
- * Service tag and companion object for {@link NodeVersionFetcher}.
- *
- * Acts as both the TypeScript service interface and the Effect dependency tag
- * used for dependency injection (companion object pattern). Yield this tag
- * inside `Effect.gen` to access the fetcher implementation provided by
- * {@link NodeVersionFetcherLive}.
- *
  * @example
  * ```typescript
  * import type { NodeReleaseInput } from "runtime-resolver";
@@ -2227,10 +2020,34 @@ export declare interface NodeVersionFetcher {
  * ```
  *
  * @see {@link NodeVersionFetcherLive}
+ * @see {@link NodeReleaseCache}
+ * @see {@link NetworkError}
+ * @see {@link ParseError}
  *
  * @public
  */
-export declare const NodeVersionFetcher: Context.Tag<NodeVersionFetcher, NodeVersionFetcher>;
+export declare class NodeVersionFetcher extends NodeVersionFetcher_base {
+}
+
+declare const NodeVersionFetcher_base: Context.TagClass<NodeVersionFetcher, "runtime-resolver/NodeVersionFetcher", {
+    /**
+     * Fetches all available Node.js releases from the distribution index and
+     * returns both the parsed semver version objects and the raw release input
+     * records.
+     *
+     * Fails with:
+     * - {@link NetworkError} — the upstream request could not be completed.
+     * - {@link ParseError} — the response payload could not be decoded.
+     */
+    readonly fetch: () => Effect.Effect<{
+        readonly versions: readonly SemVer[];
+        readonly inputs: readonly {
+            readonly version: string;
+            readonly npm: string;
+            readonly date: string;
+        }[];
+    }, NetworkError | ParseError, never>;
+}>;
 
 /**
  * Provides the {@link NodeVersionFetcher} service using the live Node.js dist index.
@@ -2264,6 +2081,24 @@ export declare const NodeVersionFetcherLive: Layer.Layer<NodeVersionFetcher, nev
  * three authentication layers: {@link GitHubTokenAuth}, {@link GitHubAppAuth},
  * or {@link GitHubAutoAuth}.
  *
+ * @example
+ * ```typescript
+ * import { OctokitInstance, GitHubClientLive, GitHubAutoAuth } from "runtime-resolver";
+ * import { Effect } from "effect";
+ *
+ * const program = Effect.gen(function* () {
+ * 	const octokit = yield* OctokitInstance;
+ * 	const response = await octokit.rest.repos.listTags({
+ * 		owner: "oven-sh",
+ * 		repo: "bun",
+ * 		per_page: 10,
+ * 	});
+ * 	console.log(response.data.length);
+ * });
+ *
+ * Effect.runPromise(program.pipe(Effect.provide(GitHubAutoAuth)));
+ * ```
+ *
  * @see {@link GitHubClientLive}
  * @see {@link GitHubTokenAuth}
  * @see {@link GitHubAppAuth}
@@ -2271,7 +2106,10 @@ export declare const NodeVersionFetcherLive: Layer.Layer<NodeVersionFetcher, nev
  *
  * @public
  */
-export declare interface OctokitInstance {
+export declare class OctokitInstance extends OctokitInstance_base {
+}
+
+declare const OctokitInstance_base: Context.TagClass<OctokitInstance, "runtime-resolver/OctokitInstance", {
     readonly rest: {
         readonly repos: {
             /**
@@ -2286,7 +2124,7 @@ export declare interface OctokitInstance {
                 per_page?: number;
                 page?: number;
             }) => Promise<{
-                data: Array<unknown>;
+                data: unknown[];
             }>;
             /**
              * Lists GitHub Releases for a repository, corresponding to
@@ -2300,50 +2138,11 @@ export declare interface OctokitInstance {
                 per_page?: number;
                 page?: number;
             }) => Promise<{
-                data: Array<unknown>;
+                data: unknown[];
             }>;
         };
     };
-}
-
-/**
- * Service tag and companion object for {@link OctokitInstance}.
- *
- * Acts as both the TypeScript service interface and the Effect dependency tag
- * used for dependency injection (companion object pattern). This tag is
- * consumed internally by {@link GitHubClientLive} and is satisfied by
- * whichever authentication layer is provided — {@link GitHubTokenAuth},
- * {@link GitHubAppAuth}, or {@link GitHubAutoAuth}.
- *
- * Most application code should depend on {@link GitHubClient} rather than
- * this tag directly.
- *
- * @example
- * ```typescript
- * import { OctokitInstance, GitHubClientLive, GitHubAutoAuth } from "runtime-resolver";
- * import { Effect } from "effect";
- *
- * const program = Effect.gen(function* () {
- * 	const octokit = yield* OctokitInstance;
- * 	const response = await octokit.rest.repos.listTags({
- * 		owner: "oven-sh",
- * 		repo: "bun",
- * 		per_page: 10,
- * 	});
- * 	console.log(response.data.length);
- * });
- *
- * Effect.runPromise(program.pipe(Effect.provide(GitHubAutoAuth)));
- * ```
- *
- * @see {@link GitHubClientLive}
- * @see {@link GitHubTokenAuth}
- * @see {@link GitHubAppAuth}
- * @see {@link GitHubAutoAuth}
- *
- * @public
- */
-export declare const OctokitInstance: Context.Tag<OctokitInstance, OctokitInstance>;
+}>;
 
 /**
  * Provides the {@link BunReleaseCache} service using the "Offline" cache strategy.
@@ -2440,23 +2239,13 @@ export declare const OfflineNodeCacheLive: Layer.Layer<NodeReleaseCache>;
  *
  * @public
  */
-export declare class ParseError extends ParseErrorBase<{
+export declare class ParseError extends ParseError_base<{
     readonly source: string;
     readonly message: string;
 }> {
 }
 
-/**
- * @internal
- * Exported for declaration bundling — see AuthenticationError.ts for details.
- *
- * @privateRemarks
- * This base constant must remain a named export so that api-extractor can
- * resolve the extends clause of {@link ParseError} to a stable declaration.
- * Without it the bundled `.d.ts` would contain an anonymous `_base` symbol
- * that cannot be referenced by downstream consumers.
- */
-export declare const ParseErrorBase: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & {
+declare const ParseError_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<    { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
     readonly _tag: "ParseError";
 } & Readonly<A>;
 
@@ -2492,7 +2281,7 @@ export declare const ParseErrorBase: new <A extends Record<string, any> = {}>(ar
  *
  * @public
  */
-export declare class RateLimitError extends RateLimitErrorBase<{
+export declare class RateLimitError extends RateLimitError_base<{
     readonly retryAfter?: number;
     readonly limit: number;
     readonly remaining: number;
@@ -2500,17 +2289,7 @@ export declare class RateLimitError extends RateLimitErrorBase<{
 }> {
 }
 
-/**
- * @internal
- * Exported for declaration bundling — see AuthenticationError.ts for details.
- *
- * @privateRemarks
- * This base constant must remain a named export so that api-extractor can
- * resolve the extends clause of {@link RateLimitError} to a stable declaration.
- * Without it the bundled `.d.ts` would contain an anonymous `_base` symbol
- * that cannot be referenced by downstream consumers.
- */
-export declare const RateLimitErrorBase: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & {
+declare const RateLimitError_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<    { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
     readonly _tag: "RateLimitError";
 } & Readonly<A>;
 
@@ -2800,7 +2579,7 @@ export declare interface RuntimeCache<R extends RuntimeRelease> {
  */
 export declare interface RuntimeRelease {
     readonly _tag: string;
-    readonly version: SemVer.SemVer;
+    readonly version: SemVer;
     readonly date: DateTime.DateTime;
 }
 
@@ -2810,7 +2589,7 @@ export declare interface RuntimeRelease {
  *
  * Both Bun and Deno source their offline snapshots from JSON/TS data files
  * whose entries conform to this shape. The `version` and `date` fields are
- * plain strings that are subsequently parsed by `SemVer.fromString` and
+ * plain strings that are subsequently parsed by `SemVer.parse` and
  * `DateTime.unsafeMake` respectively.
  *
  * @see {@link BunRelease.fromInput}
@@ -2880,24 +2659,14 @@ export declare type Source = typeof Source.Type;
  *
  * @public
  */
-export declare class VersionNotFoundError extends VersionNotFoundErrorBase<{
+export declare class VersionNotFoundError extends VersionNotFoundError_base<{
     readonly runtime: Runtime;
     readonly constraint: string;
     readonly message: string;
 }> {
 }
 
-/**
- * @internal
- * Exported for declaration bundling — see AuthenticationError.ts for details.
- *
- * @privateRemarks
- * This base constant must remain a named export so that api-extractor can
- * resolve the extends clause of {@link VersionNotFoundError} to a stable
- * declaration. Without it the bundled `.d.ts` would contain an anonymous
- * `_base` symbol that cannot be referenced by downstream consumers.
- */
-export declare const VersionNotFoundErrorBase: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & {
+declare const VersionNotFoundError_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<    { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
     readonly _tag: "VersionNotFoundError";
 } & Readonly<A>;