runtime-resolver 0.3.22 → 1.0.0

package/layers/NodeScheduleFetcherLive.js

@@ -1,37 +0,0 @@
-import { NodeScheduleFetcher } from "../services/NodeScheduleFetcher.js";
-import { GitHubClient } from "../services/GitHubClient.js";
-import { ParseError } from "../errors/ParseError.js";
-import { NodeReleaseSchedule } from "../schemas/node.js";
-import { Effect, Layer, Schema } from "effect";
-
-//#region src/layers/NodeScheduleFetcherLive.ts
-const NODE_SCHEDULE_URL = "https://raw.githubusercontent.com/nodejs/Release/refs/heads/main/schedule.json";
-const decodeSchedule = (input) => Schema.decodeUnknown(NodeReleaseSchedule)(input).pipe(Effect.mapError((e) => new ParseError({
-	source: NODE_SCHEDULE_URL,
-	message: `Schema validation failed: ${e.message}`
-})), Effect.map((data) => data));
-/**
-* Provides the {@link NodeScheduleFetcher} service using the live Node.js release schedule.
-*
-* Fetches the Node.js release schedule from the raw GitHub content URL for
-* `nodejs/Release` (`schedule.json` on the `main` branch) using the HTTP client
-* on the provided {@link GitHubClient} service. The schedule data maps major
-* version codenames to their start, LTS, and end-of-life dates and is used by
-* {@link NodeReleaseCache} to compute per-release lifecycle phases.
-*
-* This layer is a required dependency of {@link AutoNodeCacheLive} and
-* {@link FreshNodeCacheLive}. It is not needed by {@link OfflineNodeCacheLive}.
-*
-* @see {@link NodeScheduleFetcher}
-* @see {@link GitHubClient}
-* @see {@link AutoNodeCacheLive}
-* @see {@link FreshNodeCacheLive}
-* @public
-*/
-const NodeScheduleFetcherLive = Layer.effect(NodeScheduleFetcher, Effect.gen(function* () {
-	const client = yield* GitHubClient;
-	return { fetch: () => client.getJson(NODE_SCHEDULE_URL, { decode: decodeSchedule }) };
-}));
-
-//#endregion
-export { NodeScheduleFetcherLive };

package/layers/NodeVersionFetcherLive.js

@@ -1,55 +0,0 @@
-import { NodeVersionFetcher } from "../services/NodeVersionFetcher.js";
-import { tryParseSemVer } from "../lib/semver.js";
-import { GitHubClient } from "../services/GitHubClient.js";
-import { ParseError } from "../errors/ParseError.js";
-import { NodeDistIndex } from "../schemas/node.js";
-import { Effect, Layer, Option, Schema } from "effect";
-
-//#region src/layers/NodeVersionFetcherLive.ts
-const NODE_DIST_URL = "https://nodejs.org/dist/index.json";
-const decodeDistIndex = (input) => Schema.decodeUnknown(NodeDistIndex)(input).pipe(Effect.mapError((e) => new ParseError({
-	source: NODE_DIST_URL,
-	message: `Schema validation failed: ${e.message}`
-})));
-/**
-* Provides the {@link NodeVersionFetcher} service using the live Node.js dist index.
-*
-* Fetches the full Node.js version list from `https://nodejs.org/dist/index.json`
-* using the HTTP client on the provided {@link GitHubClient} service. Version
-* strings are normalized by stripping the leading `v` before parsing as semver.
-* Entries with non-string `npm` fields (present in very old releases prior to
-* v0.6.3) are substituted with the sentinel version `"0.0.0"`.
-*
-* This layer is a required dependency of {@link AutoNodeCacheLive} and
-* {@link FreshNodeCacheLive}. It is not needed by {@link OfflineNodeCacheLive}.
-*
-* @see {@link NodeVersionFetcher}
-* @see {@link GitHubClient}
-* @see {@link AutoNodeCacheLive}
-* @see {@link FreshNodeCacheLive}
-* @public
-*/
-const NodeVersionFetcherLive = Layer.effect(NodeVersionFetcher, Effect.gen(function* () {
-	const client = yield* GitHubClient;
-	return { fetch: () => Effect.gen(function* () {
-		const allVersions = yield* client.getJson(NODE_DIST_URL, { decode: decodeDistIndex });
-		const parsed = yield* Effect.forEach(allVersions, (entry) => {
-			const clean = entry.version.replace(/^v/, "");
-			return tryParseSemVer(clean).pipe(Effect.map((opt) => Option.isSome(opt) ? Option.some({
-				version: opt.value,
-				input: {
-					version: clean,
-					npm: typeof entry.npm === "string" ? entry.npm : "0.0.0",
-					date: entry.date
-				}
-			}) : Option.none()));
-		}, { concurrency: "unbounded" });
-		return {
-			versions: parsed.flatMap(Option.toArray).map(({ version }) => version),
-			inputs: parsed.flatMap(Option.toArray).map(({ input }) => input)
-		};
-	}) };
-}));
-
-//#endregion
-export { NodeVersionFetcherLive };

package/layers/OfflineBunCacheLive.js

@@ -1,40 +0,0 @@
-import { bunDefaultInputs } from "../data/bun-defaults.js";
-import { BunRelease } from "../schemas/bun-release.js";
-import { BunReleaseCache } from "../services/BunReleaseCache.js";
-import { BunReleaseCacheLive } from "./BunReleaseCacheLive.js";
-import { Effect, Layer } from "effect";
-import { SemVerParserLive, VersionCacheLive } from "semver-effect";
-
-//#region src/layers/OfflineBunCacheLive.ts
-const offlineSetup = Effect.gen(function* () {
-	const cache = yield* BunReleaseCache;
-	const releases = yield* Effect.all(bunDefaultInputs.map((input) => BunRelease.fromInput(input)), { concurrency: "unbounded" }).pipe(Effect.orElseSucceed(() => []));
-	yield* cache.load(releases);
-});
-const SemVerLayer = VersionCacheLive.pipe(Layer.provide(SemVerParserLive));
-const BaseCacheLayer = BunReleaseCacheLive.pipe(Layer.provide(SemVerLayer));
-/**
-* Provides the {@link BunReleaseCache} service using the "Offline" cache strategy.
-*
-* Uses only the bundled default Bun release data that was baked in at build time.
-* Makes no network requests and has no runtime dependencies. This layer always
-* succeeds immediately.
-*
-* Use this strategy in environments where network access is unavailable or
-* undesirable (e.g., air-gapped systems, hermetic test environments, or any
-* context where version data from the bundle is sufficient).
-*
-* The three Bun cache strategy layers are:
-* - {@link AutoBunCacheLive} — tries API first, falls back to bundled defaults on any error
-* - {@link FreshBunCacheLive} — requires live API data, fails with `FreshnessError` if unavailable
-* - `OfflineBunCacheLive` — uses only bundled defaults, no network I/O
-*
-* @see {@link BunReleaseCache}
-* @see {@link AutoBunCacheLive}
-* @see {@link FreshBunCacheLive}
-* @public
-*/
-const OfflineBunCacheLive = BaseCacheLayer.pipe(Layer.tap((ctx) => offlineSetup.pipe(Effect.provide(ctx))));
-
-//#endregion
-export { OfflineBunCacheLive };

package/layers/OfflineDenoCacheLive.js

@@ -1,40 +0,0 @@
-import { denoDefaultInputs } from "../data/deno-defaults.js";
-import { DenoRelease } from "../schemas/deno-release.js";
-import { DenoReleaseCache } from "../services/DenoReleaseCache.js";
-import { DenoReleaseCacheLive } from "./DenoReleaseCacheLive.js";
-import { Effect, Layer } from "effect";
-import { SemVerParserLive, VersionCacheLive } from "semver-effect";
-
-//#region src/layers/OfflineDenoCacheLive.ts
-const offlineSetup = Effect.gen(function* () {
-	const cache = yield* DenoReleaseCache;
-	const releases = yield* Effect.all(denoDefaultInputs.map((input) => DenoRelease.fromInput(input)), { concurrency: "unbounded" }).pipe(Effect.orElseSucceed(() => []));
-	yield* cache.load(releases);
-});
-const SemVerLayer = VersionCacheLive.pipe(Layer.provide(SemVerParserLive));
-const BaseCacheLayer = DenoReleaseCacheLive.pipe(Layer.provide(SemVerLayer));
-/**
-* Provides the {@link DenoReleaseCache} service using the "Offline" cache strategy.
-*
-* Uses only the bundled default Deno release data that was baked in at build time.
-* Makes no network requests and has no runtime dependencies. This layer always
-* succeeds immediately.
-*
-* Use this strategy in environments where network access is unavailable or
-* undesirable (e.g., air-gapped systems, hermetic test environments, or any
-* context where version data from the bundle is sufficient).
-*
-* The three Deno cache strategy layers are:
-* - {@link AutoDenoCacheLive} — tries API first, falls back to bundled defaults on any error
-* - {@link FreshDenoCacheLive} — requires live API data, fails with `FreshnessError` if unavailable
-* - `OfflineDenoCacheLive` — uses only bundled defaults, no network I/O
-*
-* @see {@link DenoReleaseCache}
-* @see {@link AutoDenoCacheLive}
-* @see {@link FreshDenoCacheLive}
-* @public
-*/
-const OfflineDenoCacheLive = BaseCacheLayer.pipe(Layer.tap((ctx) => offlineSetup.pipe(Effect.provide(ctx))));
-
-//#endregion
-export { OfflineDenoCacheLive };

package/layers/OfflineNodeCacheLive.js

@@ -1,39 +0,0 @@
-import { nodeDefaultInputs, nodeDefaultScheduleData } from "../data/node-defaults.js";
-import { NodeReleaseCache } from "../services/NodeReleaseCache.js";
-import { NodeReleaseCacheLive } from "./NodeReleaseCacheLive.js";
-import { Effect, Layer } from "effect";
-import { SemVerParserLive, VersionCacheLive } from "semver-effect";
-
-//#region src/layers/OfflineNodeCacheLive.ts
-const offlineSetup = Effect.gen(function* () {
-	const cache = yield* NodeReleaseCache;
-	yield* cache.updateSchedule(nodeDefaultScheduleData);
-	yield* cache.loadFromInputs(nodeDefaultInputs);
-});
-const SemVerLayer = VersionCacheLive.pipe(Layer.provide(SemVerParserLive));
-const BaseCacheLayer = NodeReleaseCacheLive.pipe(Layer.provide(SemVerLayer));
-/**
-* Provides the {@link NodeReleaseCache} service using the "Offline" cache strategy.
-*
-* Uses only the bundled default Node.js release data and schedule data that were
-* baked in at build time. Makes no network requests and has no runtime
-* dependencies. This layer always succeeds immediately.
-*
-* Use this strategy in environments where network access is unavailable or
-* undesirable (e.g., air-gapped systems, hermetic test environments, or any
-* context where version data from the bundle is sufficient).
-*
-* The three Node cache strategy layers are:
-* - {@link AutoNodeCacheLive} — tries API first, falls back to bundled defaults on any error
-* - {@link FreshNodeCacheLive} — requires live API data, fails with `FreshnessError` if unavailable
-* - `OfflineNodeCacheLive` — uses only bundled defaults, no network I/O
-*
-* @see {@link NodeReleaseCache}
-* @see {@link AutoNodeCacheLive}
-* @see {@link FreshNodeCacheLive}
-* @public
-*/
-const OfflineNodeCacheLive = BaseCacheLayer.pipe(Layer.tap((ctx) => offlineSetup.pipe(Effect.provide(ctx))));
-
-//#endregion
-export { OfflineNodeCacheLive };

package/layers/RuntimeCacheLive.js

@@ -1,78 +0,0 @@
-import { Effect } from "effect";
-import { Range, VersionCache } from "semver-effect";
-
-//#region src/layers/RuntimeCacheLive.ts
-/**
-* Factory that creates a {@link RuntimeCache} implementation backed by
-* `semver-effect`'s `VersionCache`.
-*
-* The returned `Effect` must be executed within an Effect context that provides
-* a `SemVerVersionCache` service (i.e., it requires `SemVerVersionCache` in its
-* environment). The cache maintains an internal lookup map from version string
-* to the full release object so that resolved semver versions can be
-* round-tripped back to their typed release records.
-*
-* This factory is used internally by {@link BunReleaseCacheLive},
-* {@link DenoReleaseCacheLive}, and {@link NodeReleaseCacheLive} to build their
-* respective cache service implementations. Prefer those higher-level layers
-* over calling this factory directly.
-*
-* Note: `load` is not concurrency-safe. Callers must not invoke it concurrently.
-* In practice this constraint is upheld because `load` is only called from layer
-* setup and `NodeReleaseCacheLive.loadFromInputs`, both of which are serialized
-* by the Effect runtime.
-*
-* @typeParam R - The runtime release type stored in the cache. Must extend
-*   {@link RuntimeRelease}.
-*
-* @see {@link RuntimeCache}
-* @see {@link BunReleaseCacheLive}
-* @see {@link DenoReleaseCacheLive}
-* @see {@link NodeReleaseCacheLive}
-* @public
-*/
-const createRuntimeCache = () => Effect.gen(function* () {
-	const innerCache = yield* VersionCache;
-	const lookupMap = /* @__PURE__ */ new Map();
-	return {
-		load: (releases) => Effect.gen(function* () {
-			lookupMap.clear();
-			const versions = [];
-			for (const r of releases) {
-				const key = r.version.toString();
-				lookupMap.set(key, r);
-				versions.push(r.version);
-			}
-			yield* innerCache.load(versions);
-		}),
-		resolve: (range) => Effect.gen(function* () {
-			const parsed = yield* Range.parse(range);
-			const resolved = yield* innerCache.resolve(parsed);
-			const release = lookupMap.get(resolved.toString());
-			if (!release) return yield* Effect.die(/* @__PURE__ */ new Error(`Cache inconsistency: ${resolved.toString()} not in lookup map`));
-			return release;
-		}),
-		releases: () => Effect.gen(function* () {
-			return (yield* innerCache.versions.pipe(Effect.catchTag("EmptyCacheError", () => Effect.succeed([])))).map((v) => lookupMap.get(v.toString())).filter((r) => r !== void 0);
-		}),
-		filter: (range) => Effect.gen(function* () {
-			const parsed = yield* Range.parse(range);
-			return (yield* innerCache.filter(parsed).pipe(Effect.catchTag("EmptyCacheError", () => Effect.succeed([])))).map((v) => lookupMap.get(v.toString())).filter((r) => r !== void 0);
-		}),
-		latest: () => Effect.gen(function* () {
-			const version = yield* innerCache.latest();
-			const release = lookupMap.get(version.toString());
-			if (!release) return yield* Effect.die(/* @__PURE__ */ new Error(`Cache inconsistency: ${version.toString()} not in lookup map`));
-			return release;
-		}),
-		latestByMajor: () => Effect.gen(function* () {
-			return (yield* innerCache.latestByMajor().pipe(Effect.catchTag("EmptyCacheError", () => Effect.succeed([])))).map((v) => lookupMap.get(v.toString())).filter((r) => r !== void 0);
-		}),
-		latestByMinor: () => Effect.gen(function* () {
-			return (yield* innerCache.latestByMinor().pipe(Effect.catchTag("EmptyCacheError", () => Effect.succeed([])))).map((v) => lookupMap.get(v.toString())).filter((r) => r !== void 0);
-		})
-	};
-});
-
-//#endregion
-export { createRuntimeCache };

package/lib/retry.js

@@ -1,27 +0,0 @@
-import { Effect, Predicate, Schedule } from "effect";
-
-//#region src/lib/retry.ts
-/**
-* Wraps an effect with automatic retry logic for {@link RateLimitError}.
-*
-* When the wrapped effect fails with a `RateLimitError` the retry schedule
-* applies exponential backoff starting at a 1-second base delay, doubling on
-* each attempt, for a maximum of 3 retries. Errors with any other tag are
-* re-raised immediately without retrying.
-*
-* The predicate used for the `while` condition is
-* `Predicate.isTagged("RateLimitError")`, so only errors whose `_tag` field
-* equals `"RateLimitError"` trigger a retry; all other error types propagate
-* unchanged.
-*
-* @see {@link RateLimitError}
-*
-* @internal
-*/
-const retryOnRateLimit = (effect) => effect.pipe(Effect.retry({
-	schedule: Schedule.exponential("1 second").pipe(Schedule.compose(Schedule.recurs(3))),
-	while: Predicate.isTagged("RateLimitError")
-}));
-
-//#endregion
-export { retryOnRateLimit };

package/lib/semver.js

@@ -1,21 +0,0 @@
-import { Effect, Option } from "effect";
-import { SemVer } from "semver-effect";
-
-//#region src/lib/semver.ts
-/**
-* Attempts to parse a raw version string into a {@link SemVer}, returning
-* `Option.none()` when the string is not a valid semver value.
-*
-* Unlike `SemVer.parse` — which fails the effect on an unparseable input —
-* this helper absorbs parse failures and promotes them into the `Option` channel
-* so that callers can handle invalid versions without short-circuiting the
-* surrounding effect pipeline.
-*
-* @see {@link SemVer.parse}
-*
-* @internal
-*/
-const tryParseSemVer = (raw) => SemVer.parse(raw).pipe(Effect.map(Option.some), Effect.catchAll(() => Effect.succeed(Option.none())));
-
-//#endregion
-export { tryParseSemVer };

package/schemas/bun-release.js

@@ -1,63 +0,0 @@
-import { Data, DateTime, Effect } from "effect";
-import { SemVer } from "semver-effect";
-
-//#region src/schemas/bun-release.ts
-/**
-* A Bun release entry with a parsed `SemVer` version and an
-* Effect `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.parse`.
-*
-* @see {@link BunReleaseCache}
-* @see {@link BunResolver}
-* @see `RuntimeReleaseInput`
-*
-* @example
-* ```typescript
-* import { Effect } from "effect";
-* import type { BunRelease } from "./bun-release.js";
-* import { BunRelease as BunReleaseClass } from "./bun-release.js";
-*
-* const program = BunReleaseClass.fromInput({ version: "1.1.0", date: "2024-03-01" }).pipe(
-*   Effect.map((release: BunRelease) => {
-*     console.log(release.version.major); // 1
-*     console.log(release.version.minor); // 1
-*     console.log(release._tag);          // "BunRelease"
-*   }),
-* );
-*
-* Effect.runPromise(program);
-* ```
-*
-* @public
-*/
-var BunRelease = class BunRelease extends Data.TaggedClass("BunRelease") {
-	/**
-	* Create a {@link BunRelease} from lean string inputs.
-	*
-	* 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).
-	*
-	* @param input - A `RuntimeReleaseInput` object with raw string fields.
-	* @returns An `Effect` that succeeds with a `BunRelease` or fails with an
-	*   `InvalidVersionError` when the version string cannot be parsed.
-	*/
-	static fromInput(input) {
-		return Effect.gen(function* () {
-			const version = yield* SemVer.parse(input.version);
-			const date = input.date ? DateTime.unsafeMake(input.date) : DateTime.unsafeMake(/* @__PURE__ */ new Date());
-			return new BunRelease({
-				version,
-				date
-			});
-		});
-	}
-};
-
-//#endregion
-export { BunRelease };

package/schemas/deno-release.js

@@ -1,63 +0,0 @@
-import { Data, DateTime, Effect } from "effect";
-import { SemVer } from "semver-effect";
-
-//#region src/schemas/deno-release.ts
-/**
-* A Deno release entry with a parsed `SemVer` version and an
-* Effect `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.parse`.
-*
-* @see {@link DenoReleaseCache}
-* @see {@link DenoResolver}
-* @see `RuntimeReleaseInput`
-*
-* @example
-* ```typescript
-* import { Effect } from "effect";
-* import type { DenoRelease } from "./deno-release.js";
-* import { DenoRelease as DenoReleaseClass } from "./deno-release.js";
-*
-* const program = DenoReleaseClass.fromInput({ version: "1.44.0", date: "2024-05-23" }).pipe(
-*   Effect.map((release: DenoRelease) => {
-*     console.log(release.version.major); // 1
-*     console.log(release.version.minor); // 44
-*     console.log(release._tag);          // "DenoRelease"
-*   }),
-* );
-*
-* Effect.runPromise(program);
-* ```
-*
-* @public
-*/
-var DenoRelease = class DenoRelease extends Data.TaggedClass("DenoRelease") {
-	/**
-	* Create a {@link DenoRelease} from lean string inputs.
-	*
-	* 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).
-	*
-	* @param input - A `RuntimeReleaseInput` object with raw string fields.
-	* @returns An `Effect` that succeeds with a `DenoRelease` or fails with an
-	*   `InvalidVersionError` when the version string cannot be parsed.
-	*/
-	static fromInput(input) {
-		return Effect.gen(function* () {
-			const version = yield* SemVer.parse(input.version);
-			const date = input.date ? DateTime.unsafeMake(input.date) : DateTime.unsafeMake(/* @__PURE__ */ new Date());
-			return new DenoRelease({
-				version,
-				date
-			});
-		});
-	}
-};
-
-//#endregion
-export { DenoRelease };

package/schemas/github.js

@@ -1,74 +0,0 @@
-import { Schema } from "effect";
-
-//#region src/schemas/github.ts
-/**
-* The `commit` sub-object returned for each entry in the GitHub tags API.
-*
-* Used as a nested field within {@link GitHubTag}.
-*
-* @see {@link GitHubClient}
-*
-* @public
-*/
-const GitHubTagCommit = Schema.Struct({
-	sha: Schema.String,
-	url: Schema.String
-});
-/**
-* A single tag entry as returned by the GitHub REST API
-* (`GET /repos/{owner}/{repo}/tags`).
-*
-* Consumed by {@link GitHubClient} when fetching Bun and Deno release tags.
-*
-* @see {@link GitHubClient}
-* @see `GitHubTagList`
-*
-* @public
-*/
-const GitHubTag = Schema.Struct({
-	name: Schema.String,
-	zipball_url: Schema.String,
-	tarball_url: Schema.String,
-	commit: GitHubTagCommit,
-	node_id: Schema.String
-});
-/**
-* The decoded response body from `GET /repos/{owner}/{repo}/tags`.
-*
-* @see {@link GitHubClient}
-* @see {@link GitHubTag}
-*
-* @public
-*/
-const GitHubTagList = Schema.Array(GitHubTag);
-/**
-* A single release entry as returned by the GitHub REST API
-* (`GET /repos/{owner}/{repo}/releases`).
-*
-* Consumed by {@link GitHubClient} when fetching Deno releases that carry
-* publication timestamps.
-*
-* @see {@link GitHubClient}
-* @see `GitHubReleaseList`
-*
-* @public
-*/
-const GitHubRelease = Schema.Struct({
-	tag_name: Schema.String,
-	name: Schema.NullOr(Schema.String),
-	draft: Schema.Boolean,
-	prerelease: Schema.Boolean,
-	published_at: Schema.NullOr(Schema.String)
-});
-/**
-* The decoded response body from `GET /repos/{owner}/{repo}/releases`.
-*
-* @see {@link GitHubClient}
-* @see {@link GitHubRelease}
-*
-* @public
-*/
-const GitHubReleaseList = Schema.Array(GitHubRelease);
-
-//#endregion
-export { GitHubRelease, GitHubReleaseList, GitHubTag, GitHubTagCommit, GitHubTagList };

package/schemas/node-release.js

@@ -1,133 +0,0 @@
-import { DateTime, Effect, Ref, Schema } from "effect";
-import { SemVer } from "semver-effect";
-
-//#region src/schemas/node-release.ts
-/**
-* Lean input schema used to construct {@link NodeRelease} instances from
-* bundled default data files and the Node.js dist API response.
-*
-* The `version` and `npm` fields are raw version strings validated by
-* `SemVer.parse`; `date` is a date string accepted by
-* `DateTime.unsafeMake`.
-*
-* @see {@link NodeRelease.fromInput}
-* @see {@link NodeVersionFetcher}
-*
-* @public
-*/
-const NodeReleaseInput = Schema.Struct({
-	version: Schema.String,
-	npm: Schema.String,
-	date: Schema.String
-});
-/**
-* A Node.js release entry with parsed version, bundled npm version,
-* publication date, and a shared reference to the Node.js release schedule.
-*
-* `NodeRelease` is a plain class rather than a `Data.TaggedClass` because it
-* holds a `Ref<NodeSchedule>` — mutable Effect references break structural
-* equality semantics, making `Data.TaggedClass` unsuitable here. The
-* `_tag` field is set manually to preserve tagged-union compatibility.
-*
-* Use {@link NodeRelease.fromInput} to construct instances; call
-* {@link NodeRelease.phase} or {@link NodeRelease.lts} to query the lifecycle
-* state of the release at a given point in time.
-*
-* @see {@link NodeReleaseCache}
-* @see {@link NodeResolver}
-* @see {@link NodeSchedule}
-*
-* @example
-* ```typescript
-* import { Effect, Ref } from "effect";
-* import type { NodePhase } from "./common.js";
-* import type { NodeRelease } from "./node-release.js";
-* import { NodeRelease as NodeReleaseClass } from "./node-release.js";
-* import { NodeSchedule } from "./node-schedule.js";
-*
-* const program = Effect.gen(function* () {
-*   const schedule = NodeSchedule.fromData({
-*     v20: { start: "2023-04-18", lts: "2023-10-24", end: "2026-04-30" },
-*   });
-*   const scheduleRef = yield* Ref.make(schedule);
-*
-*   const release: NodeRelease = yield* NodeReleaseClass.fromInput(
-*     { version: "v20.0.0", npm: "9.6.4", date: "2023-04-18" },
-*     scheduleRef,
-*   );
-*
-*   const phase: NodePhase | null = yield* release.phase();
-*   const isLts: boolean = yield* release.lts();
-*   console.log(phase);  // e.g. "active-lts"
-*   console.log(isLts);  // true
-* });
-*
-* Effect.runPromise(program);
-* ```
-*
-* @public
-*/
-var NodeRelease = class NodeRelease {
-	version;
-	npm;
-	date;
-	scheduleRef;
-	_tag = "NodeRelease";
-	constructor(version, npm, date, scheduleRef) {
-		this.version = version;
-		this.npm = npm;
-		this.date = date;
-		this.scheduleRef = scheduleRef;
-	}
-	/**
-	* Determine this release's lifecycle phase at the given point in time.
-	*
-	* Reads the current value of the shared `scheduleRef` and delegates to
-	* {@link NodeSchedule.phaseFor}. Defaults to the current wall-clock time
-	* when `now` is omitted.
-	*
-	* @param now - Optional reference time; defaults to `new Date()`.
-	* @returns An `Effect` that resolves to a `NodePhase` string, or
-	*   `null` when the major version is not present in the schedule or has
-	*   not yet been released.
-	*/
-	phase(now) {
-		const effectiveNow = now ?? DateTime.unsafeMake(/* @__PURE__ */ new Date());
-		return Effect.gen(this, function* () {
-			return yield* (yield* Ref.get(this.scheduleRef)).phaseFor(this.version.major, effectiveNow);
-		});
-	}
-	/**
-	* Whether this release is currently in Long-Term Support.
-	*
-	* Returns `true` for both `"active-lts"` and `"maintenance-lts"` phases.
-	* Defaults to the current wall-clock time when `now` is omitted.
-	*
-	* @param now - Optional reference time; defaults to `new Date()`.
-	*/
-	lts(now) {
-		return this.phase(now).pipe(Effect.map((p) => p === "active-lts" || p === "maintenance-lts"));
-	}
-	/**
-	* Create a {@link NodeRelease} from lean string inputs.
-	*
-	* Parses `input.version` and `input.npm` via `SemVer.parse` and
-	* constructs the publication date with `DateTime.unsafeMake`.
-	*
-	* @param input - A {@link (NodeReleaseInput:type)} object with raw string fields.
-	* @param scheduleRef - A shared `Ref<NodeSchedule>` injected by the cache layer.
-	* @returns An `Effect` that succeeds with a `NodeRelease` or fails with an
-	*   `InvalidVersionError` when either version string cannot be parsed.
-	*/
-	static fromInput(input, scheduleRef) {
-		return Effect.gen(function* () {
-			const version = yield* SemVer.parse(input.version);
-			const npm = yield* SemVer.parse(input.npm);
-			const date = DateTime.unsafeMake(input.date);
-			return new NodeRelease(version, npm, date, scheduleRef);
-		});
-	}
-};
-
-//#endregion
-export { NodeRelease };