runtime-resolver 0.3.22 → 1.0.0

package/errors/AuthenticationError.js

@@ -1,35 +0,0 @@
-import { Data } from "effect";
-
-//#region src/errors/AuthenticationError.ts
-/**
-* Raised when a GitHub authentication attempt fails.
-*
-* This error is produced by the {@link GitHubTokenAuth} and
-* {@link GitHubAppAuth} layers when the supplied credentials are rejected by
-* the GitHub API or when required configuration values (e.g. a token or app
-* private key) are missing from the environment.
-*
-* @see {@link GitHubTokenAuth}
-* @see {@link GitHubAppAuth}
-*
-* @example
-* ```typescript
-* import { Effect } from "effect";
-* import type { AuthenticationError } from "./AuthenticationError.js";
-* import { resolveNode } from "../resolvers/node.js";
-*
-* const program = resolveNode(">=20").pipe(
-*   Effect.catchTag("AuthenticationError", (err: AuthenticationError) =>
-*     Effect.logError(
-*       `Auth failed via ${err.method}: ${err.message}`
-*     ).pipe(Effect.andThen(Effect.fail(err)))
-*   )
-* );
-* ```
-*
-* @public
-*/
-var AuthenticationError = class extends Data.TaggedError("AuthenticationError") {};
-
-//#endregion
-export { AuthenticationError };

package/errors/CacheError.js

@@ -1,32 +0,0 @@
-import { Data } from "effect";
-
-//#region src/errors/CacheError.ts
-/**
-* Raised when a cache read or write operation fails.
-*
-* This error surfaces when the local on-disk version cache cannot be accessed
-* or updated. The `operation` field distinguishes between failures that occur
-* while loading cached data (`"read"`) and failures that occur while
-* persisting new data (`"write"`).
-*
-* @example
-* ```typescript
-* import { Effect } from "effect";
-* import type { CacheError } from "./CacheError.js";
-* import { resolveNode } from "../resolvers/node.js";
-*
-* const program = resolveNode(">=20").pipe(
-*   Effect.catchTag("CacheError", (err: CacheError) =>
-*     Effect.logWarning(
-*       `Cache ${err.operation} failed: ${err.message}`
-*     ).pipe(Effect.andThen(Effect.fail(err)))
-*   )
-* );
-* ```
-*
-* @public
-*/
-var CacheError = class extends Data.TaggedError("CacheError") {};
-
-//#endregion
-export { CacheError };

package/errors/FreshnessError.js

@@ -1,38 +0,0 @@
-import { Data } from "effect";
-
-//#region src/errors/FreshnessError.ts
-/**
-* Raised when a cache freshness check cannot be completed.
-*
-* Each runtime cache layer ({@link FreshBunCacheLive}, {@link FreshDenoCacheLive},
-* {@link FreshNodeCacheLive}) validates whether locally stored version data is
-* still current before returning it. This error is produced when that
-* validation fails — for example, when the upstream API is unreachable during
-* an `"api"` freshness check, or when the cached timestamp is corrupt during
-* an `"auto"` or `"cache"` check.
-*
-* @see {@link FreshBunCacheLive}
-* @see {@link FreshDenoCacheLive}
-* @see {@link FreshNodeCacheLive}
-*
-* @example
-* ```typescript
-* import { Effect } from "effect";
-* import type { FreshnessError } from "./FreshnessError.js";
-* import { resolveNode } from "../resolvers/node.js";
-*
-* const program = resolveNode(">=20").pipe(
-*   Effect.catchTag("FreshnessError", (err: FreshnessError) =>
-*     Effect.logWarning(
-*       `Freshness check (${err.strategy}) failed: ${err.message}`
-*     ).pipe(Effect.andThen(Effect.fail(err)))
-*   )
-* );
-* ```
-*
-* @public
-*/
-var FreshnessError = class extends Data.TaggedError("FreshnessError") {};
-
-//#endregion
-export { FreshnessError };

package/errors/InvalidInputError.js

@@ -1,33 +0,0 @@
-import { Data } from "effect";
-
-//#region src/errors/InvalidInputError.ts
-/**
-* Raised when a caller-supplied value fails validation.
-*
-* This error is produced at the boundary where user-provided inputs (such as
-* version constraint strings or runtime identifiers) are decoded against their
-* expected schemas. The `field` identifies which input was invalid, `value`
-* carries the raw string that was rejected, and `message` explains the
-* specific violation.
-*
-* @example
-* ```typescript
-* import { Effect } from "effect";
-* import type { InvalidInputError } from "./InvalidInputError.js";
-* import { resolveNode } from "../resolvers/node.js";
-*
-* const program = resolveNode("not-a-semver-range").pipe(
-*   Effect.catchTag("InvalidInputError", (err: InvalidInputError) =>
-*     Effect.logError(
-*       `Invalid value for "${err.field}": ${err.value} — ${err.message}`
-*     ).pipe(Effect.andThen(Effect.fail(err)))
-*   )
-* );
-* ```
-*
-* @public
-*/
-var InvalidInputError = class extends Data.TaggedError("InvalidInputError") {};
-
-//#endregion
-export { InvalidInputError };

package/errors/NetworkError.js

@@ -1,34 +0,0 @@
-import { Data } from "effect";
-
-//#region src/errors/NetworkError.ts
-/**
-* Raised when an HTTP request to an upstream API fails.
-*
-* This error is produced when a fetch to a runtime release API (e.g. the
-* Node.js release index, the Deno release feed, or the Bun GitHub releases
-* endpoint) either does not receive a response or receives a non-successful
-* HTTP status code. When a status code is available it is included in the
-* `status` field; for connection-level failures (timeouts, DNS errors) that
-* field is absent.
-*
-* @example
-* ```typescript
-* import { Effect } from "effect";
-* import type { NetworkError } from "./NetworkError.js";
-* import { resolveNode } from "../resolvers/node.js";
-*
-* const program = resolveNode(">=20").pipe(
-*   Effect.catchTag("NetworkError", (err: NetworkError) =>
-*     Effect.logError(
-*       `Request to ${err.url} failed${err.status != null ? ` with status ${err.status}` : ""}: ${err.message}`
-*     ).pipe(Effect.andThen(Effect.fail(err)))
-*   )
-* );
-* ```
-*
-* @public
-*/
-var NetworkError = class extends Data.TaggedError("NetworkError") {};
-
-//#endregion
-export { NetworkError };

package/errors/ParseError.js

@@ -1,33 +0,0 @@
-import { Data } from "effect";
-
-//#region src/errors/ParseError.ts
-/**
-* Raised when the body of an upstream API response cannot be decoded.
-*
-* This error is produced after a successful HTTP response is received but
-* its payload does not match the expected shape — for example, when a release
-* index returns malformed JSON or when a required field is missing from the
-* response structure. The `source` field identifies the URL or data source
-* that produced the unparseable content.
-*
-* @example
-* ```typescript
-* import { Effect } from "effect";
-* import type { ParseError } from "./ParseError.js";
-* import { resolveNode } from "../resolvers/node.js";
-*
-* const program = resolveNode(">=20").pipe(
-*   Effect.catchTag("ParseError", (err: ParseError) =>
-*     Effect.logError(
-*       `Failed to parse response from ${err.source}: ${err.message}`
-*     ).pipe(Effect.andThen(Effect.fail(err)))
-*   )
-* );
-* ```
-*
-* @public
-*/
-var ParseError = class extends Data.TaggedError("ParseError") {};
-
-//#endregion
-export { ParseError };

package/errors/RateLimitError.js

@@ -1,37 +0,0 @@
-import { Data } from "effect";
-
-//#region src/errors/RateLimitError.ts
-/**
-* Raised when a GitHub API rate limit is exceeded.
-*
-* The `limit` and `remaining` fields reflect the values returned in the
-* `X-RateLimit-Limit` and `X-RateLimit-Remaining` response headers. When the
-* API indicates how long to wait before the quota resets, that duration (in
-* seconds) is available via `retryAfter`.
-*
-* Use `retryOnRateLimit` to automatically retry an effect with
-* exponential backoff whenever this error is encountered.
-*
-* @example
-* ```typescript
-* import { Effect } from "effect";
-* import type { RateLimitError } from "./RateLimitError.js";
-* import { resolveNode } from "../resolvers/node.js";
-*
-* const program = resolveNode(">=20").pipe(
-*   Effect.catchTag("RateLimitError", (err: RateLimitError) =>
-*     Effect.logWarning(
-*       `Rate limit hit (${err.remaining}/${err.limit} remaining)` +
-*       (err.retryAfter != null ? `, retry after ${err.retryAfter}s` : "") +
-*       `: ${err.message}`
-*     ).pipe(Effect.andThen(Effect.fail(err)))
-*   )
-* );
-* ```
-*
-* @public
-*/
-var RateLimitError = class extends Data.TaggedError("RateLimitError") {};
-
-//#endregion
-export { RateLimitError };

package/errors/VersionNotFoundError.js

@@ -1,37 +0,0 @@
-import { Data } from "effect";
-
-//#region src/errors/VersionNotFoundError.ts
-/**
-* Raised when no published version satisfies the requested constraint.
-*
-* This error is produced by {@link NodeResolver}, {@link BunResolver}, and
-* {@link DenoResolver} after the full list of available versions has been
-* fetched and filtered but no entry matches the caller-supplied semver
-* constraint. The `runtime` field identifies which runtime was queried and
-* `constraint` echoes the range string that was provided.
-*
-* @see {@link NodeResolver}
-* @see {@link BunResolver}
-* @see {@link DenoResolver}
-*
-* @example
-* ```typescript
-* import { Effect } from "effect";
-* import type { VersionNotFoundError } from "./VersionNotFoundError.js";
-* import { resolveNode } from "../resolvers/node.js";
-*
-* const program = resolveNode(">=999").pipe(
-*   Effect.catchTag("VersionNotFoundError", (err: VersionNotFoundError) =>
-*     Effect.logError(
-*       `No ${err.runtime} version matched "${err.constraint}": ${err.message}`
-*     ).pipe(Effect.andThen(Effect.fail(err)))
-*   )
-* );
-* ```
-*
-* @public
-*/
-var VersionNotFoundError = class extends Data.TaggedError("VersionNotFoundError") {};
-
-//#endregion
-export { VersionNotFoundError };