@effected/runtimes 0.1.0

package/index.d.ts

@@ -0,0 +1,737 @@
+import { InvalidRangeError, SemVer } from "@effected/semver";
+import { Context, DateTime, Effect, Layer, Option, Redacted, Schema } from "effect";
+import { HttpClient } from "effect/unstable/http";
+//#region src/GitHub.d.ts
+declare const AuthenticationError_base: Schema.Class<AuthenticationError, Schema.TaggedStruct<"AuthenticationError", {
+  /** How the request was authenticated when it was rejected. */
+  readonly method: Schema.Literals<readonly ["token", "anonymous"]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * GitHub rejected the credentials.
+ *
+ * @public
+ */
+declare class AuthenticationError extends AuthenticationError_base {}
+declare const RateLimitError_base: Schema.Class<RateLimitError, Schema.TaggedStruct<"RateLimitError", {
+  /** Seconds to wait before retrying, when GitHub said. */
+  readonly retryAfter: Schema.optionalKey<Schema.Number>;
+  /** The request quota for the window. */
+  readonly limit: Schema.Number;
+  /** Requests left in the window. */
+  readonly remaining: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * GitHub's rate limit was exhausted.
+ *
+ * `retryAfter` is what a caller needs to back off correctly, which is why it is
+ * a structured field rather than prose in a message.
+ *
+ * @public
+ */
+declare class RateLimitError extends RateLimitError_base {}
+declare const NetworkError_base: Schema.Class<NetworkError, Schema.TaggedStruct<"NetworkError", {
+  /** The URL that failed. */
+  readonly url: Schema.String;
+  /** The HTTP status, when there was a response at all. */
+  readonly status: Schema.optionalKey<Schema.Number>;
+  /** The underlying transport failure. */
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A request did not complete, or completed with an unusable status.
+ *
+ * @public
+ */
+declare class NetworkError extends NetworkError_base {}
+declare const ResponseParseError_base: Schema.Class<ResponseParseError, Schema.TaggedStruct<"ResponseParseError", {
+  /** The URL whose body could not be decoded. */
+  readonly source: Schema.String;
+  /** The decoding failure. */
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A feed responded, but not with the shape this package expects.
+ *
+ * An operator-facing signal that an upstream feed changed.
+ *
+ * @public
+ */
+declare class ResponseParseError extends ResponseParseError_base {}
+/**
+ * Every way a fetch against a release feed can fail.
+ *
+ * @public
+ */
+type GitHubError = AuthenticationError | RateLimitError | NetworkError | ResponseParseError;
+declare const GitHubTag_base: Schema.Class<GitHubTag, Schema.Struct<{
+  readonly name: Schema.String;
+}>, {}>;
+/**
+ * A tag as `GET /repos/{owner}/{repo}/tags` returns it.
+ *
+ * @public
+ */
+declare class GitHubTag extends GitHubTag_base {}
+declare const GitHubRelease_base: Schema.Class<GitHubRelease, Schema.Struct<{
+  readonly tag_name: Schema.String;
+  readonly draft: Schema.Boolean;
+  readonly prerelease: Schema.Boolean;
+  readonly published_at: Schema.NullOr<Schema.String>;
+}>, {}>;
+/**
+ * A release as `GET /repos/{owner}/{repo}/releases` returns it.
+ *
+ * @public
+ */
+declare class GitHubRelease extends GitHubRelease_base {}
+/**
+ * The shape of a GitHub credential: something that can produce request headers.
+ *
+ * Making this a service rather than a concrete token is what lets GitHub App
+ * authentication live outside this package. App auth needs JWT signing and an
+ * installation-token exchange, which means a runtime dependency — forbidden in
+ * a boundary-tier package. A consumer who needs it supplies their own
+ * `Layer<GitHubAuth>` that mints installation tokens; nothing else changes.
+ *
+ * @public
+ */
+interface GitHubAuthShape {
+  /** Headers to attach to each GitHub request. */
+  readonly headers: Effect.Effect<Readonly<Record<string, string>>, AuthenticationError>;
+}
+declare const GitHubAuth_base: Context.ServiceClass<GitHubAuth, "@effected/runtimes/GitHubAuth", GitHubAuthShape>;
+/**
+ * How GitHub requests are authenticated.
+ *
+ * @public
+ */
+declare class GitHubAuth extends GitHubAuth_base {
+  /**
+   * Send no credentials. GitHub allows this, at a much lower rate limit.
+   */
+  static readonly anonymous: Layer.Layer<GitHubAuth>;
+  /**
+   * Authenticate with a personal access token.
+   *
+   * This returns a fresh layer per call, so bind it to a constant rather than
+   * calling it inline twice — layers are memoized by reference.
+   */
+  static readonly token: (token: Redacted.Redacted<string>) => Layer.Layer<GitHubAuth>;
+  /**
+   * Detect a credential from the environment, preferring an explicit PAT.
+   *
+   * Precedence is `GITHUB_PERSONAL_ACCESS_TOKEN`, then `GITHUB_TOKEN`, then
+   * unauthenticated — the v3 policy, kept, but read through `Config` so a test
+   * can swap the `ConfigProvider` instead of mutating `process.env`.
+   */
+  static readonly layer: Layer.Layer<GitHubAuth>;
+}
+/**
+ * How much of a paginated listing to fetch.
+ *
+ * Both fields must be positive integers. A `NaN` or fractional value is a
+ * wiring bug, not a data condition, and dies rather than failing typed.
+ *
+ * The fields are declared here rather than inherited from the engine's
+ * `PageOptions`, which is internal: a `@public` signature may not name a type a
+ * consumer cannot import.
+ *
+ * @public
+ */
+interface ListOptions {
+  /** Items per page. Defaults to 100, GitHub's maximum. */
+  readonly perPage?: number;
+  /** Pages to fetch. Defaults to 5, and is capped regardless. */
+  readonly pages?: number;
+}
+/**
+ * The GitHub REST operations this package needs.
+ *
+ * @public
+ */
+interface GitHubClientShape {
+  /** List a repository's tags, newest first. */
+  readonly listTags: (owner: string, repo: string, options?: ListOptions) => Effect.Effect<ReadonlyArray<GitHubTag>, GitHubError>;
+  /** List a repository's releases, newest first. */
+  readonly listReleases: (owner: string, repo: string, options?: ListOptions) => Effect.Effect<ReadonlyArray<GitHubRelease>, GitHubError>;
+}
+declare const GitHubClient_base: Context.ServiceClass<GitHubClient, "@effected/runtimes/GitHubClient", GitHubClientShape>;
+/**
+ * A GitHub REST client over `HttpClient`.
+ *
+ * v3 reached for `octokit` here, which cost two large dependency graphs to fund
+ * two GET requests. Programming against `HttpClient` from `effect` core keeps
+ * the package boundary tier and lets a consumer supply any transport.
+ *
+ * @public
+ */
+declare class GitHubClient extends GitHubClient_base {
+  /**
+   * The client, requiring an `HttpClient` and a `GitHubAuth` from the context.
+   */
+  static readonly layer: Layer.Layer<GitHubClient, never, HttpClient.HttpClient | GitHubAuth>;
+  /**
+   * The client with batteries: environment-detected auth over `fetch`.
+   *
+   * The common wiring, in one import. Use {@link GitHubClient.layer} directly
+   * to supply your own credential or transport.
+   */
+  static readonly layerDefault: Layer.Layer<GitHubClient>;
+}
+//#endregion
+//#region src/ResolvedVersions.d.ts
+/**
+ * The JavaScript runtime a resolver targets.
+ *
+ * @public
+ */
+declare const Runtime: Schema.Literals<readonly ["node", "bun", "deno"]>;
+/**
+ * The JavaScript runtime a resolver targets.
+ *
+ * @public
+ */
+type Runtime = typeof Runtime.Type;
+/**
+ * Where a resolution's release data came from.
+ *
+ * - `api` — a live fetch of the upstream feed succeeded.
+ * - `cache` — the bundled snapshot was used, either because the offline
+ *   strategy was chosen or because the auto strategy fell back to it.
+ *
+ * This is honest provenance. In v3 the field existed, was advertised as a
+ * headline feature, and was hardcoded to `"api"` by every resolver — so a
+ * caller could not tell a live answer from a snapshot served after a silent
+ * network failure.
+ *
+ * @public
+ */
+declare const Source: Schema.Literals<readonly ["api", "cache"]>;
+/**
+ * Where a resolution's release data came from.
+ *
+ * @public
+ */
+type Source = typeof Source.Type;
+/**
+ * The granularity at which matching versions are grouped.
+ *
+ * - `latest` — the newest version of each major line.
+ * - `minor` — the newest patch of each minor line.
+ * - `patch` — every matching release.
+ *
+ * @public
+ */
+declare const Increments: Schema.Literals<readonly ["latest", "minor", "patch"]>;
+/**
+ * The granularity at which matching versions are grouped.
+ *
+ * @public
+ */
+type Increments = typeof Increments.Type;
+declare const ResolvedVersions_base: Schema.Class<ResolvedVersions, Schema.Struct<{
+  /** Whether this answer came from a live feed or the bundled snapshot. */
+  readonly source: Schema.Literals<readonly ["api", "cache"]>;
+  /** Every matching version, newest first. */
+  readonly versions: Schema.$Array<Schema.String>;
+  /** The newest matching version. Always present — an empty match is an error, not an empty result. */
+  readonly latest: Schema.String;
+  /** The newest matching LTS version. Node only, and only when one matches. */
+  readonly lts: Schema.optionalKey<Schema.String>;
+  /** The version the caller asked to treat as the default, resolved. */
+  readonly default: Schema.optionalKey<Schema.String>;
+}>, {}>;
+/**
+ * What every resolver returns.
+ *
+ * @public
+ */
+declare class ResolvedVersions extends ResolvedVersions_base {}
+declare const NoMatchingVersionError_base: Schema.Class<NoMatchingVersionError, Schema.TaggedStruct<"NoMatchingVersionError", {
+  /** The runtime that was searched. */
+  readonly runtime: Schema.Literals<readonly ["node", "bun", "deno"]>;
+  /** The semver range that matched nothing. */
+  readonly constraint: Schema.String;
+  /** The lifecycle phases the search was restricted to. Node only. */
+  readonly phases: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["current", "active-lts", "maintenance-lts", "end-of-life"]>>>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * No release matched the constraint.
+ *
+ * Distinct from an invalid constraint: `@effected/semver`'s `InvalidRangeError`
+ * says the range is malformed, this says the range is fine and nothing matched.
+ * v3 collapsed the former into the latter, so a typo in a range surfaced to the
+ * user as "no versions found".
+ *
+ * @public
+ */
+declare class NoMatchingVersionError extends NoMatchingVersionError_base {}
+declare const UnresolvableDefaultError_base: Schema.Class<UnresolvableDefaultError, Schema.TaggedStruct<"UnresolvableDefaultError", {
+  /** The runtime that was searched. */
+  readonly runtime: Schema.Literals<readonly ["node", "bun", "deno"]>;
+  /** The range the caller asked to treat as the default. */
+  readonly defaultVersion: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * An explicit `defaultVersion` was asked for and nothing matched it.
+ *
+ * Distinct from {@link NoMatchingVersionError}, which says the *main* range
+ * matched nothing. Here the main range resolved fine and the caller's separate
+ * default range did not.
+ *
+ * It has to be its own failure rather than a silently dropped field. `default`
+ * is `optionalKey`, so an unresolvable default could simply be omitted — and for
+ * Node, whose default falls back to the LTS pick, the caller would then be handed
+ * the LTS version as though they had asked for it. Naming a default that does not
+ * exist is a mistake, and it reaches the caller as one.
+ *
+ * @public
+ */
+declare class UnresolvableDefaultError extends UnresolvableDefaultError_base {}
+declare const FreshnessError_base: Schema.Class<FreshnessError, Schema.TaggedStruct<"FreshnessError", {
+  /** The runtime whose feed could not be reached. */
+  readonly runtime: Schema.Literals<readonly ["node", "bun", "deno"]>;
+  /** The underlying transport or parse failure. */
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Fresh data was required and could not be obtained.
+ *
+ * Raised only by the `layerFresh` strategy, at layer construction: the caller
+ * asked for live data and said, by choosing that strategy, that a snapshot is
+ * not an acceptable substitute.
+ *
+ * @public
+ */
+declare class FreshnessError extends FreshnessError_base {}
+//#endregion
+//#region src/BunResolver.d.ts
+declare const BunRelease_base: Schema.Class<BunRelease, Schema.Struct<{
+  /** The released version. */
+  readonly version: typeof SemVer;
+  /** When it was published. */
+  readonly date: Schema.DateTimeUtc;
+}>, {}>;
+/**
+ * One published Bun release.
+ *
+ * @public
+ */
+declare class BunRelease extends BunRelease_base {}
+/**
+ * How to resolve Bun versions.
+ *
+ * @public
+ */
+declare const BunResolverOptions: Schema.Struct<{
+  /** The semver range to match. Defaults to `*`. */
+  readonly range: Schema.optionalKey<Schema.String>;
+  /** How to group matches. Defaults to `latest`. */
+  readonly increments: Schema.optionalKey<Schema.Literals<readonly ["latest", "minor", "patch"]>>;
+  /** A range whose newest match becomes the `default` field. */
+  readonly defaultVersion: Schema.optionalKey<Schema.String>;
+}>;
+/**
+ * How to resolve Bun versions.
+ *
+ * @public
+ */
+type BunResolverOptions = typeof BunResolverOptions.Type;
+declare const BunResolver_base: Context.ServiceClass<BunResolver, "@effected/runtimes/BunResolver", {
+  readonly resolve: (options?: BunResolverOptions) => Effect.Effect<ResolvedVersions, InvalidRangeError | NoMatchingVersionError | UnresolvableDefaultError>;
+}>;
+/**
+ * The Bun resolver.
+ *
+ * @example
+ * ```ts
+ * import { BunResolver } from "@effected/runtimes";
+ * import { Effect } from "effect";
+ *
+ * const program = Effect.gen(function* () {
+ *   const resolver = yield* BunResolver;
+ *   return (yield* resolver.resolve({ range: "^1.0.0" })).latest;
+ * }).pipe(Effect.provide(BunResolver.layerOffline));
+ * ```
+ *
+ * @public
+ */
+declare class BunResolver extends BunResolver_base {
+  /** Try GitHub, fall back to the bundled snapshot. */
+  static readonly layer: Layer.Layer<BunResolver, never, GitHubClient>;
+  /** GitHub or nothing. Fails with `FreshnessError` when it cannot be reached. */
+  static readonly layerFresh: Layer.Layer<BunResolver, FreshnessError, GitHubClient>;
+  /** The bundled snapshot only. Performs no IO and requires nothing. */
+  static readonly layerOffline: Layer.Layer<BunResolver>;
+}
+//#endregion
+//#region src/DenoResolver.d.ts
+declare const DenoRelease_base: Schema.Class<DenoRelease, Schema.Struct<{
+  /** The released version. */
+  readonly version: typeof SemVer;
+  /** When it was published. */
+  readonly date: Schema.DateTimeUtc;
+}>, {}>;
+/**
+ * One published Deno release.
+ *
+ * @public
+ */
+declare class DenoRelease extends DenoRelease_base {}
+/**
+ * How to resolve Deno versions.
+ *
+ * @public
+ */
+declare const DenoResolverOptions: Schema.Struct<{
+  /** The semver range to match. Defaults to `*`. */
+  readonly range: Schema.optionalKey<Schema.String>;
+  /** How to group matches. Defaults to `latest`. */
+  readonly increments: Schema.optionalKey<Schema.Literals<readonly ["latest", "minor", "patch"]>>;
+  /** A range whose newest match becomes the `default` field. */
+  readonly defaultVersion: Schema.optionalKey<Schema.String>;
+}>;
+/**
+ * How to resolve Deno versions.
+ *
+ * @public
+ */
+type DenoResolverOptions = typeof DenoResolverOptions.Type;
+declare const DenoResolver_base: Context.ServiceClass<DenoResolver, "@effected/runtimes/DenoResolver", {
+  readonly resolve: (options?: DenoResolverOptions) => Effect.Effect<ResolvedVersions, InvalidRangeError | NoMatchingVersionError | UnresolvableDefaultError>;
+}>;
+/**
+ * The Deno resolver.
+ *
+ * @example
+ * ```ts
+ * import { DenoResolver } from "@effected/runtimes";
+ * import { Effect } from "effect";
+ *
+ * const program = Effect.gen(function* () {
+ *   const resolver = yield* DenoResolver;
+ *   return (yield* resolver.resolve({ range: "^2.0.0" })).latest;
+ * }).pipe(Effect.provide(DenoResolver.layerOffline));
+ * ```
+ *
+ * @public
+ */
+declare class DenoResolver extends DenoResolver_base {
+  /** Try GitHub, fall back to the bundled snapshot. */
+  static readonly layer: Layer.Layer<DenoResolver, never, GitHubClient>;
+  /** GitHub or nothing. Fails with `FreshnessError` when it cannot be reached. */
+  static readonly layerFresh: Layer.Layer<DenoResolver, FreshnessError, GitHubClient>;
+  /** The bundled snapshot only. Performs no IO and requires nothing. */
+  static readonly layerOffline: Layer.Layer<DenoResolver>;
+}
+//#endregion
+//#region src/NodeSchedule.d.ts
+/**
+ * Lifecycle phase of a Node.js major release line.
+ *
+ * - `current` — actively receiving features and bug fixes.
+ * - `active-lts` — Long-Term Support: bug and security fixes only.
+ * - `maintenance-lts` — critical security fixes only.
+ * - `end-of-life` — no longer maintained.
+ *
+ * @public
+ */
+declare const NodePhase: Schema.Literals<readonly ["current", "active-lts", "maintenance-lts", "end-of-life"]>;
+/**
+ * Lifecycle phase of a Node.js major release line.
+ *
+ * @public
+ */
+type NodePhase = typeof NodePhase.Type;
+declare const InvalidScheduleDateError_base: Schema.Class<InvalidScheduleDateError, Schema.TaggedStruct<"InvalidScheduleDateError", {
+  /** The schedule key whose entry failed, e.g. `"v20"`. */
+  readonly key: Schema.String;
+  /** The field that failed, e.g. `"start"`. */
+  readonly field: Schema.String;
+  /** The value that could not be parsed. */
+  readonly value: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A date in the release schedule could not be understood.
+ *
+ * Raised when `nodejs/Release` publishes a `schedule.json` whose dates this
+ * package cannot parse — an operator-facing signal that the upstream feed
+ * changed shape, not something a caller can recover from.
+ *
+ * @public
+ */
+declare class InvalidScheduleDateError extends InvalidScheduleDateError_base {}
+/**
+ * The parts of a version that decide which release line it belongs to.
+ *
+ * Structural, so a `SemVer` satisfies it without this module naming one.
+ *
+ * @public
+ */
+interface NodeReleaseLine {
+  /** The major version. */
+  readonly major: number;
+  /** The minor version. Only consulted for the `0.x` lines; defaults to `0`. */
+  readonly minor?: number | undefined;
+}
+/**
+ * The release-line key a version belongs to.
+ *
+ * Node's early history is the whole reason this exists. `nodejs/Release`
+ * publishes `v0.8`, `v0.10` and `v0.12` as three *separate* release lines with
+ * their own start and end dates — the major number does not identify them.
+ * Everything from `v4` on is keyed by the major alone.
+ *
+ * @example
+ * ```ts
+ * import { nodeReleaseLine } from "@effected/runtimes";
+ *
+ * nodeReleaseLine({ major: 20, minor: 11 }); // "20"
+ * nodeReleaseLine({ major: 0, minor: 12 });  // "0.12"
+ * ```
+ *
+ * @public
+ */
+declare const nodeReleaseLine: (version: NodeReleaseLine) => string;
+declare const NodeScheduleEntry_base: Schema.Class<NodeScheduleEntry, Schema.Struct<{
+  /**
+   * The release line as `nodejs/Release` keys it, without the `v`: `"20"`, or
+   * `"0.10"` for the three dotted early lines.
+   */
+  readonly line: Schema.String;
+  /** The Node.js major version number, e.g. `20`. `0` for every `0.x` line. */
+  readonly major: Schema.Number;
+  /** The minor, for the `0.x` lines that are each their own release line. */
+  readonly minor: Schema.optionalKey<Schema.Number>;
+  /** When the line was first released. */
+  readonly start: Schema.DateTimeUtc;
+  /** When the line entered Active LTS, absent if it never does (odd majors). */
+  readonly lts: Schema.optionalKey<Schema.DateTimeUtc>;
+  /** When the line entered Maintenance LTS. */
+  readonly maintenance: Schema.optionalKey<Schema.DateTimeUtc>;
+  /** When the line reaches end of life. */
+  readonly end: Schema.DateTimeUtc;
+  /** The LTS codename, e.g. `"Iron"`. Empty for lines that never got one. */
+  readonly codename: Schema.String;
+}>, {}>;
+/**
+ * One release line's lifecycle dates.
+ *
+ * @public
+ */
+declare class NodeScheduleEntry extends NodeScheduleEntry_base {}
+/**
+ * The raw shape of `schedule.json` as `nodejs/Release` publishes it: a map of
+ * `"vNN"` to ISO date strings.
+ *
+ * @public
+ */
+declare const NodeScheduleData: Schema.$Record<Schema.String, Schema.Struct<{
+  readonly start: Schema.String;
+  readonly lts: Schema.optionalKey<Schema.String>;
+  readonly maintenance: Schema.optionalKey<Schema.String>;
+  readonly end: Schema.String;
+  readonly codename: Schema.optionalKey<Schema.String>;
+}>>;
+/**
+ * The raw shape of `schedule.json`.
+ *
+ * @public
+ */
+type NodeScheduleData = typeof NodeScheduleData.Type;
+declare const NodeSchedule_base: Schema.Class<NodeSchedule, Schema.Struct<{
+  /** The known release lines, ascending by major. */
+  readonly entries: Schema.$Array<typeof NodeScheduleEntry>;
+}>, {}>;
+/**
+ * An immutable snapshot of the Node.js release schedule.
+ *
+ * In v3 a `Ref<NodeSchedule>` was threaded *into every `NodeRelease`* so that
+ * `release.phase()` could reach the schedule — mutable service state inside an
+ * immutable domain value, which is why `NodeRelease` could not be a data class.
+ * Here the schedule is a value the caller passes in: phase is a function of
+ * `(release, schedule, now)`, and nothing in the model is mutable.
+ *
+ * @example
+ * ```ts
+ * import { NodeSchedule } from "@effected/runtimes";
+ * import { DateTime, Effect, Option } from "effect";
+ *
+ * const program = Effect.gen(function* () {
+ *   const schedule = yield* NodeSchedule.fromData({
+ *     v20: { start: "2023-04-18", lts: "2023-10-24", end: "2026-04-30" },
+ *   });
+ *   const phase = schedule.phaseFor({ major: 20 }, DateTime.makeUnsafe("2024-01-01"));
+ *   return Option.getOrNull(phase); // "active-lts"
+ * });
+ * ```
+ *
+ * @public
+ */
+declare class NodeSchedule extends NodeSchedule_base {
+  /**
+   * A schedule that knows nothing.
+   *
+   * `phaseFor` returns `Option.none()` for every major, which is the correct
+   * answer before a schedule has been loaded.
+   */
+  static readonly empty: NodeSchedule;
+  /**
+   * Parse the raw `schedule.json` shape into a schedule.
+   *
+   * Keys that are not of the form `"vNN"` are skipped — the upstream file has
+   * historically carried non-version keys, and one of them is not a reason to
+   * fail the whole schedule. A key that *is* a version but whose dates do not
+   * parse fails with {@link InvalidScheduleDateError}.
+   */
+  static readonly fromData: (data: {
+    readonly [x: string]: {
+      readonly start: string;
+      readonly lts?: string | undefined;
+      readonly maintenance?: string | undefined;
+      readonly end: string;
+      readonly codename?: string | undefined;
+    };
+  }) => Effect.Effect<NodeSchedule, InvalidScheduleDateError, never>;
+  /**
+   * The schedule entry for a version's release line, if the schedule knows it.
+   */
+  entryFor(version: NodeReleaseLine): Option.Option<NodeScheduleEntry>;
+  /**
+   * The lifecycle phase of a version's release line at a point in time.
+   *
+   * `now` is an explicit parameter rather than a read of the wall clock, which
+   * is what makes every phase transition testable without mocking time.
+   *
+   * Returns `Option.none()` when the schedule does not know the line, or when
+   * `now` is before the line was released — an unreleased line has no phase.
+   */
+  phaseFor(version: NodeReleaseLine, now: DateTime.Utc): Option.Option<NodePhase>;
+}
+/**
+ * Whether a phase counts as Long-Term Support.
+ *
+ * @public
+ */
+declare const isLtsPhase: (phase: NodePhase) => boolean;
+//#endregion
+//#region src/NodeRelease.d.ts
+declare const NodeRelease_base: Schema.Class<NodeRelease, Schema.Struct<{
+  /** The released version. */
+  readonly version: typeof SemVer;
+  /** The npm version bundled with it. */
+  readonly npm: typeof SemVer;
+  /** When it was published. */
+  readonly date: Schema.DateTimeUtc;
+}>, {}>;
+/**
+ * One Node.js release.
+ *
+ * Unlike its v3 ancestor this is an ordinary immutable value. v3's `NodeRelease`
+ * carried a `Ref<NodeSchedule>` so that `release.phase()` could reach the
+ * schedule, which meant every release held shared mutable state and could not be
+ * a data class at all. Phase is now a question you ask *with* a schedule rather
+ * than a property the release drags around.
+ *
+ * @example
+ * ```ts
+ * import { NodeRelease, NodeSchedule } from "@effected/runtimes";
+ * import { DateTime, Effect } from "effect";
+ *
+ * const program = Effect.gen(function* () {
+ *   const schedule = yield* NodeSchedule.fromData({
+ *     v20: { start: "2023-04-18", lts: "2023-10-24", end: "2026-04-30" },
+ *   });
+ *   const release = NodeRelease.make({
+ *     version: yield* SemVer.parse("20.11.0"),
+ *     npm: yield* SemVer.parse("10.2.4"),
+ *     date: DateTime.makeUnsafe("2024-01-09"),
+ *   });
+ *   return release.isLts(schedule, DateTime.makeUnsafe("2024-06-01")); // true
+ * });
+ * ```
+ *
+ * @public
+ */
+declare class NodeRelease extends NodeRelease_base {
+  /**
+   * This release's lifecycle phase at a point in time.
+   *
+   * The release line, not the major, is what the schedule is keyed by: `0.10`
+   * and `0.12` are separate lines with separate end dates, so asking by major
+   * alone would answer `0.12` with `0.8`'s schedule.
+   *
+   * `Option.none()` when the schedule does not cover this line, or when `now`
+   * predates the line's release.
+   */
+  phase(schedule: NodeSchedule, now: DateTime.Utc): Option.Option<NodePhase>;
+  /**
+   * Whether this release is in Long-Term Support at a point in time.
+   */
+  isLts(schedule: NodeSchedule, now: DateTime.Utc): boolean;
+}
+//#endregion
+//#region src/NodeResolver.d.ts
+/**
+ * How to resolve Node.js versions.
+ *
+ * @public
+ */
+declare const NodeResolverOptions: Schema.Struct<{
+  /** The semver range to match. Defaults to `*`. */
+  readonly range: Schema.optionalKey<Schema.String>;
+  /** Lifecycle phases to accept. Defaults to `current` and `active-lts`. */
+  readonly phases: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["current", "active-lts", "maintenance-lts", "end-of-life"]>>>;
+  /** How to group matches. Defaults to `latest`. */
+  readonly increments: Schema.optionalKey<Schema.Literals<readonly ["latest", "minor", "patch"]>>;
+  /** A range whose newest match becomes the `default` field. Defaults to the LTS pick. */
+  readonly defaultVersion: Schema.optionalKey<Schema.String>;
+  /** The moment to evaluate lifecycle phases at. Defaults to now, read from `Clock`. */
+  readonly date: Schema.optionalKey<Schema.DateTimeUtc>;
+}>;
+/**
+ * How to resolve Node.js versions.
+ *
+ * @public
+ */
+type NodeResolverOptions = typeof NodeResolverOptions.Type;
+declare const NodeResolver_base: Context.ServiceClass<NodeResolver, "@effected/runtimes/NodeResolver", {
+  readonly resolve: (options?: NodeResolverOptions) => Effect.Effect<ResolvedVersions, InvalidRangeError | NoMatchingVersionError | UnresolvableDefaultError>;
+}>;
+/**
+ * The Node.js resolver.
+ *
+ * @example
+ * ```ts
+ * import { NodeResolver } from "@effected/runtimes";
+ * import { Effect } from "effect";
+ *
+ * const program = Effect.gen(function* () {
+ *   const resolver = yield* NodeResolver;
+ *   const result = yield* resolver.resolve({ range: ">=20", phases: ["active-lts"] });
+ *   return result.latest;
+ * }).pipe(Effect.provide(NodeResolver.layerOffline));
+ * ```
+ *
+ * @public
+ */
+declare class NodeResolver extends NodeResolver_base {
+  /**
+   * Try the live feeds, fall back to the bundled snapshot.
+   *
+   * A fallback is recorded as `source: "cache"` and logged, so a caller can
+   * always tell a live answer from a snapshot.
+   */
+  static readonly layer: Layer.Layer<NodeResolver, never, HttpClient.HttpClient>;
+  /**
+   * Live feeds or nothing. Fails with `FreshnessError` when they cannot be reached.
+   */
+  static readonly layerFresh: Layer.Layer<NodeResolver, FreshnessError, HttpClient.HttpClient>;
+  /**
+   * The bundled snapshot only. Performs no IO and requires nothing.
+   */
+  static readonly layerOffline: Layer.Layer<NodeResolver>;
+}
+//#endregion
+export { AuthenticationError, BunRelease, BunResolver, BunResolverOptions, DenoRelease, DenoResolver, DenoResolverOptions, FreshnessError, GitHubAuth, type GitHubAuthShape, GitHubClient, type GitHubClientShape, type GitHubError, GitHubRelease, GitHubTag, Increments, InvalidScheduleDateError, type ListOptions, NetworkError, NoMatchingVersionError, NodePhase, NodeRelease, type NodeReleaseLine, NodeResolver, NodeResolverOptions, NodeSchedule, NodeScheduleData, NodeScheduleEntry, RateLimitError, ResolvedVersions, ResponseParseError, Runtime, Source, UnresolvableDefaultError, isLtsPhase, nodeReleaseLine };
+//# sourceMappingURL=index.d.ts.map