runtime-resolver 0.2.0 → 0.3.1

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,29 @@ 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) => Effect.Effect<ResolvedVersions, BunResolverError>;
+}>;
 
 /**
  * Union of all typed errors that {@link BunResolver.resolve} can fail with.
@@ -419,13 +365,30 @@ 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}.
  *
+ * @example
+ * ```typescript
+ * import type { RuntimeReleaseInput } from "runtime-resolver";
+ * import { BunVersionFetcher, BunVersionFetcherLive, GitHubAutoAuth } from "runtime-resolver";
+ * import { Effect } from "effect";
+ *
+ * const program = Effect.gen(function* () {
+ * 	const fetcher = yield* BunVersionFetcher;
+ * 	const { versions, inputs } = yield* fetcher.fetch();
+ * 	console.log(`Fetched ${versions.length} Bun releases`);
+ * });
+ *
+ * Effect.runPromise(
+ * 	program.pipe(Effect.provide(BunVersionFetcherLive), Effect.provide(GitHubAutoAuth)),
+ * );
+ * ```
+ *
  * @see {@link BunVersionFetcherLive}
  * @see {@link BunReleaseCache}
  * @see {@link AuthenticationError}
@@ -435,7 +398,10 @@ export declare interface BunResolverOptions {
  *
  * @public
  */
-export declare interface 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.
@@ -447,41 +413,10 @@ export declare interface BunVersionFetcher {
      * - {@link RateLimitError} — the GitHub API rate limit was exceeded.
      */
     readonly fetch: () => Effect.Effect<{
-        readonly versions: ReadonlyArray<SemVer.SemVer>;
+        readonly versions: ReadonlyArray<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";
- * import { BunVersionFetcher, BunVersionFetcherLive, GitHubAutoAuth } from "runtime-resolver";
- * import { Effect } from "effect";
- *
- * const program = Effect.gen(function* () {
- * 	const fetcher = yield* BunVersionFetcher;
- * 	const { versions, inputs } = yield* fetcher.fetch();
- * 	console.log(`Fetched ${versions.length} Bun releases`);
- * });
- *
- * Effect.runPromise(
- * 	program.pipe(Effect.provide(BunVersionFetcherLive), Effect.provide(GitHubAutoAuth)),
- * );
- * ```
- *
- * @see {@link BunVersionFetcherLive}
- *
- * @public
- */
-export declare const BunVersionFetcher: Context.Tag<BunVersionFetcher, BunVersionFetcher>;
+}>;
 
 /**
  * Provides the {@link BunVersionFetcher} service using the live GitHub API.
@@ -527,23 +462,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 +504,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 +536,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 +554,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 +576,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 +608,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 +631,29 @@ 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) => Effect.Effect<ResolvedVersions, DenoResolverError>;
+}>;
 
 /**
  * Union of all typed errors that {@link DenoResolver.resolve} can fail with.
@@ -860,13 +745,30 @@ 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}.
  *
+ * @example
+ * ```typescript
+ * import type { RuntimeReleaseInput } from "runtime-resolver";
+ * import { DenoVersionFetcher, DenoVersionFetcherLive, GitHubAutoAuth } from "runtime-resolver";
+ * import { Effect } from "effect";
+ *
+ * const program = Effect.gen(function* () {
+ * 	const fetcher = yield* DenoVersionFetcher;
+ * 	const { versions, inputs } = yield* fetcher.fetch();
+ * 	console.log(`Fetched ${versions.length} Deno releases`);
+ * });
+ *
+ * Effect.runPromise(
+ * 	program.pipe(Effect.provide(DenoVersionFetcherLive), Effect.provide(GitHubAutoAuth)),
+ * );
+ * ```
+ *
  * @see {@link DenoVersionFetcherLive}
  * @see {@link DenoReleaseCache}
  * @see {@link AuthenticationError}
@@ -876,7 +778,10 @@ export declare interface DenoResolverOptions {
  *
  * @public
  */
-export declare interface 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.
@@ -888,41 +793,10 @@ export declare interface DenoVersionFetcher {
      * - {@link RateLimitError} — the GitHub API rate limit was exceeded.
      */
     readonly fetch: () => Effect.Effect<{
-        readonly versions: ReadonlyArray<SemVer.SemVer>;
+        readonly versions: ReadonlyArray<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";
- * import { DenoVersionFetcher, DenoVersionFetcherLive, GitHubAutoAuth } from "runtime-resolver";
- * import { Effect } from "effect";
- *
- * const program = Effect.gen(function* () {
- * 	const fetcher = yield* DenoVersionFetcher;
- * 	const { versions, inputs } = yield* fetcher.fetch();
- * 	console.log(`Fetched ${versions.length} Deno releases`);
- * });
- *
- * Effect.runPromise(
- * 	program.pipe(Effect.provide(DenoVersionFetcherLive), Effect.provide(GitHubAutoAuth)),
- * );
- * ```
- *
- * @see {@link DenoVersionFetcherLive}
- *
- * @public
- */
-export declare const DenoVersionFetcher: Context.Tag<DenoVersionFetcher, DenoVersionFetcher>;
+}>;
 
 /**
  * Provides the {@link DenoVersionFetcher} service using the live GitHub API.
@@ -1022,23 +896,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>;
 
@@ -1087,7 +951,7 @@ export declare const FreshNodeCacheLive: Layer.Layer<NodeReleaseCache, Freshness
  * @see {@link GitHubTokenAuth}
  * @public
  */
-export declare const GitHubAppAuth: (config: GitHubAppAuthConfig) => Layer.Layer<OctokitInstance, AuthenticationError, never>;
+export declare const GitHubAppAuth: (config: GitHubAppAuthConfig) => Layer.Layer<OctokitInstance, AuthenticationError>;
 
 /**
  * Configuration required to authenticate as a GitHub App installation.
@@ -1142,7 +1006,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 +1015,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`.
@@ -1207,39 +1091,7 @@ export declare interface GitHubClient {
     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>;
+}>;
 
 /**
  * Provides the {@link GitHubClient} service backed by an {@link OctokitInstance}.
@@ -1361,7 +1213,7 @@ export declare const GitHubTokenAuth: Layer.Layer<OctokitInstance>;
  * @see {@link GitHubAppAuth}
  * @public
  */
-export declare const GitHubTokenAuthFromToken: (token: string) => Layer.Layer<OctokitInstance, never, never>;
+export declare const GitHubTokenAuthFromToken: (token: string) => Layer.Layer<OctokitInstance>;
 
 /**
  * Controls the granularity at which matching versions are grouped when a
@@ -1408,24 +1260,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 +1318,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 +1402,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 +1433,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 +1449,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 +1469,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
@@ -1693,23 +1528,7 @@ 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>;
+}>;
 
 /**
  * Low-level layer that constructs the {@link NodeReleaseCache} service backed by
@@ -1740,7 +1559,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 +1583,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 +1614,30 @@ 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) => Effect.Effect<ResolvedVersions, NodeResolverError>;
+}>;
 
 /**
  * Union of all typed errors that {@link NodeResolver.resolve} can fail with.
@@ -1998,7 +1805,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 +1839,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 +1886,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 +1909,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>;
+}>;
 
 /**
  * Provides the {@link NodeScheduleFetcher} service using the live Node.js release schedule.
@@ -2171,7 +1952,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 +1961,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 +1977,30 @@ 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: ReadonlyArray<SemVer>;
+        readonly inputs: ReadonlyArray<NodeReleaseInput>;
+    }, NetworkError | ParseError>;
+}>;
 
 /**
  * Provides the {@link NodeVersionFetcher} service using the live Node.js dist index.
@@ -2264,6 +2034,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 +2059,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: {
             /**
@@ -2304,46 +2095,7 @@ export declare interface OctokitInstance {
             }>;
         };
     };
-}
-
-/**
- * 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 +2192,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 +2234,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 +2242,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>;
 
@@ -2541,13 +2273,7 @@ export declare const RateLimitErrorBase: new <A extends Record<string, any> = {}
  *
  * @public
  */
-export declare const resolveBun: (options?: BunResolverOptions | undefined) => Promise<{
-    readonly source: "api" | "cache";
-    readonly versions: readonly string[];
-    readonly latest: string;
-    readonly lts?: string | undefined;
-    readonly default?: string | undefined;
-}>;
+export declare const resolveBun: (options?: BunResolverOptions) => Promise<ResolvedVersions>;
 
 /**
  * Resolve Deno versions matching the given options.
@@ -2576,13 +2302,7 @@ export declare const resolveBun: (options?: BunResolverOptions | undefined) => P
  *
  * @public
  */
-export declare const resolveDeno: (options?: DenoResolverOptions | undefined) => Promise<{
-    readonly source: "api" | "cache";
-    readonly versions: readonly string[];
-    readonly latest: string;
-    readonly lts?: string | undefined;
-    readonly default?: string | undefined;
-}>;
+export declare const resolveDeno: (options?: DenoResolverOptions) => Promise<ResolvedVersions>;
 
 /**
  * The primary return type produced by every runtime resolver.
@@ -2664,13 +2384,7 @@ export declare type ResolvedVersions = typeof ResolvedVersions.Type;
  *
  * @public
  */
-export declare const resolveNode: (options?: NodeResolverOptions | undefined) => Promise<{
-    readonly source: "api" | "cache";
-    readonly versions: readonly string[];
-    readonly latest: string;
-    readonly lts?: string | undefined;
-    readonly default?: string | undefined;
-}>;
+export declare const resolveNode: (options?: NodeResolverOptions) => Promise<ResolvedVersions>;
 
 /**
  * Discriminates which JavaScript runtime a resolver targets.
@@ -2800,7 +2514,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 +2524,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 +2594,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>;