runtime-resolver 0.3.12 → 0.3.13

package/schemas/github.js

@@ -0,0 +1,75 @@
+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 {@link 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 {@link 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 { GitHubReleaseList, GitHubTagList };
+//# sourceMappingURL=github.js.map

package/schemas/github.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"github.js","names":[],"sources":["../../../../src/schemas/github.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\n/**\n * The `commit` sub-object returned for each entry in the GitHub tags API.\n *\n * Used as a nested field within {@link GitHubTag}.\n *\n * @see {@link GitHubClient}\n *\n * @public\n */\nexport const GitHubTagCommit = Schema.Struct({\n\tsha: Schema.String,\n\turl: Schema.String,\n});\n\n/**\n * A single tag entry as returned by the GitHub REST API\n * (`GET /repos/{owner}/{repo}/tags`).\n *\n * Consumed by {@link GitHubClient} when fetching Bun and Deno release tags.\n *\n * @see {@link GitHubClient}\n * @see {@link GitHubTagList}\n *\n * @public\n */\nexport const GitHubTag = Schema.Struct({\n\tname: Schema.String,\n\tzipball_url: Schema.String,\n\ttarball_url: Schema.String,\n\tcommit: GitHubTagCommit,\n\tnode_id: Schema.String,\n});\n\n/**\n * A single tag entry as returned by the GitHub REST API.\n *\n * @see {@link GitHubClient}\n *\n * @public\n */\nexport type GitHubTag = typeof GitHubTag.Type;\n\n/**\n * The decoded response body from `GET /repos/{owner}/{repo}/tags`.\n *\n * @see {@link GitHubClient}\n * @see {@link GitHubTag}\n *\n * @public\n */\nexport const GitHubTagList = Schema.Array(GitHubTag);\n\n/**\n * The decoded response body from `GET /repos/{owner}/{repo}/tags`.\n *\n * @see {@link GitHubClient}\n *\n * @public\n */\nexport type GitHubTagList = typeof GitHubTagList.Type;\n\n/**\n * A single release entry as returned by the GitHub REST API\n * (`GET /repos/{owner}/{repo}/releases`).\n *\n * Consumed by {@link GitHubClient} when fetching Deno releases that carry\n * publication timestamps.\n *\n * @see {@link GitHubClient}\n * @see {@link GitHubReleaseList}\n *\n * @public\n */\nexport const GitHubRelease = Schema.Struct({\n\ttag_name: Schema.String,\n\tname: Schema.NullOr(Schema.String),\n\tdraft: Schema.Boolean,\n\tprerelease: Schema.Boolean,\n\tpublished_at: Schema.NullOr(Schema.String),\n});\n\n/**\n * A single release entry as returned by the GitHub REST API.\n *\n * @see {@link GitHubClient}\n *\n * @public\n */\nexport type GitHubRelease = typeof GitHubRelease.Type;\n\n/**\n * The decoded response body from `GET /repos/{owner}/{repo}/releases`.\n *\n * @see {@link GitHubClient}\n * @see {@link GitHubRelease}\n *\n * @public\n */\nexport const GitHubReleaseList = Schema.Array(GitHubRelease);\n\n/**\n * The decoded response body from `GET /repos/{owner}/{repo}/releases`.\n *\n * @see {@link GitHubClient}\n *\n * @public\n */\nexport type GitHubReleaseList = typeof GitHubReleaseList.Type;\n"],"mappings":";;;;;;;;;;;;AAWA,MAAa,kBAAkB,OAAO,OAAO;CAC5C,KAAK,OAAO;CACZ,KAAK,OAAO;AACb,CAAC;;;;;;;;;;;;AAaD,MAAa,YAAY,OAAO,OAAO;CACtC,MAAM,OAAO;CACb,aAAa,OAAO;CACpB,aAAa,OAAO;CACpB,QAAQ;CACR,SAAS,OAAO;AACjB,CAAC;;;;;;;;;AAmBD,MAAa,gBAAgB,OAAO,MAAM,SAAS;;;;;;;;;;;;;AAuBnD,MAAa,gBAAgB,OAAO,OAAO;CAC1C,UAAU,OAAO;CACjB,MAAM,OAAO,OAAO,OAAO,MAAM;CACjC,OAAO,OAAO;CACd,YAAY,OAAO;CACnB,cAAc,OAAO,OAAO,OAAO,MAAM;AAC1C,CAAC;;;;;;;;;AAmBD,MAAa,oBAAoB,OAAO,MAAM,aAAa"}

package/schemas/node-release.js

@@ -0,0 +1,131 @@
+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 {@link 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} 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* () {
+			return new NodeRelease(yield* SemVer.parse(input.version), yield* SemVer.parse(input.npm), DateTime.unsafeMake(input.date), scheduleRef);
+		});
+	}
+};
+
+//#endregion
+export { NodeRelease };
+//# sourceMappingURL=node-release.js.map

package/schemas/node-release.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-release.js","names":[],"sources":["../../../../src/schemas/node-release.ts"],"sourcesContent":["import { DateTime, Effect, Ref, Schema } from \"effect\";\nimport type { InvalidVersionError } from \"semver-effect\";\nimport { SemVer } from \"semver-effect\";\nimport type { NodePhase } from \"./common.js\";\nimport type { NodeSchedule } from \"./node-schedule.js\";\n\n/**\n * Lean input schema used to construct {@link NodeRelease} instances from\n * bundled default data files and the Node.js dist API response.\n *\n * The `version` and `npm` fields are raw version strings validated by\n * `SemVer.parse`; `date` is a date string accepted by\n * `DateTime.unsafeMake`.\n *\n * @see {@link NodeRelease.fromInput}\n * @see {@link NodeVersionFetcher}\n *\n * @public\n */\nexport const NodeReleaseInput = Schema.Struct({\n\tversion: Schema.String,\n\tnpm: Schema.String,\n\tdate: Schema.String,\n});\n\n/**\n * Lean input type used to construct {@link NodeRelease} instances.\n *\n * @see {@link NodeRelease.fromInput}\n *\n * @public\n */\nexport type NodeReleaseInput = typeof NodeReleaseInput.Type;\n\n/**\n * A Node.js release entry with parsed version, bundled npm version,\n * publication date, and a shared reference to the Node.js release schedule.\n *\n * `NodeRelease` is a plain class rather than a `Data.TaggedClass` because it\n * holds a `Ref<NodeSchedule>` — mutable Effect references break structural\n * equality semantics, making `Data.TaggedClass` unsuitable here. The\n * `_tag` field is set manually to preserve tagged-union compatibility.\n *\n * Use {@link NodeRelease.fromInput} to construct instances; call\n * {@link NodeRelease.phase} or {@link NodeRelease.lts} to query the lifecycle\n * state of the release at a given point in time.\n *\n * @see {@link NodeReleaseCache}\n * @see {@link NodeResolver}\n * @see {@link NodeSchedule}\n *\n * @example\n * ```typescript\n * import { Effect, Ref } from \"effect\";\n * import type { NodePhase } from \"./common.js\";\n * import type { NodeRelease } from \"./node-release.js\";\n * import { NodeRelease as NodeReleaseClass } from \"./node-release.js\";\n * import { NodeSchedule } from \"./node-schedule.js\";\n *\n * const program = Effect.gen(function* () {\n *   const schedule = NodeSchedule.fromData({\n *     v20: { start: \"2023-04-18\", lts: \"2023-10-24\", end: \"2026-04-30\" },\n *   });\n *   const scheduleRef = yield* Ref.make(schedule);\n *\n *   const release: NodeRelease = yield* NodeReleaseClass.fromInput(\n *     { version: \"v20.0.0\", npm: \"9.6.4\", date: \"2023-04-18\" },\n *     scheduleRef,\n *   );\n *\n *   const phase: NodePhase | null = yield* release.phase();\n *   const isLts: boolean = yield* release.lts();\n *   console.log(phase);  // e.g. \"active-lts\"\n *   console.log(isLts);  // true\n * });\n *\n * Effect.runPromise(program);\n * ```\n *\n * @public\n */\nexport class NodeRelease {\n\treadonly _tag = \"NodeRelease\" as const;\n\n\tconstructor(\n\t\treadonly version: SemVer,\n\t\treadonly npm: SemVer,\n\t\treadonly date: DateTime.DateTime,\n\t\treadonly scheduleRef: Ref.Ref<NodeSchedule>,\n\t) {}\n\n\t/**\n\t * Determine this release's lifecycle phase at the given point in time.\n\t *\n\t * Reads the current value of the shared `scheduleRef` and delegates to\n\t * {@link NodeSchedule.phaseFor}. Defaults to the current wall-clock time\n\t * when `now` is omitted.\n\t *\n\t * @param now - Optional reference time; defaults to `new Date()`.\n\t * @returns An `Effect` that resolves to a {@link NodePhase} string, or\n\t *   `null` when the major version is not present in the schedule or has\n\t *   not yet been released.\n\t */\n\tphase(now?: DateTime.DateTime): Effect.Effect<NodePhase | null> {\n\t\tconst effectiveNow = now ?? DateTime.unsafeMake(new Date());\n\t\treturn Effect.gen(this, function* () {\n\t\t\tconst schedule = yield* Ref.get(this.scheduleRef);\n\t\t\treturn yield* schedule.phaseFor(this.version.major, effectiveNow);\n\t\t});\n\t}\n\n\t/**\n\t * Whether this release is currently in Long-Term Support.\n\t *\n\t * Returns `true` for both `\"active-lts\"` and `\"maintenance-lts\"` phases.\n\t * Defaults to the current wall-clock time when `now` is omitted.\n\t *\n\t * @param now - Optional reference time; defaults to `new Date()`.\n\t */\n\tlts(now?: DateTime.DateTime): Effect.Effect<boolean> {\n\t\treturn this.phase(now).pipe(Effect.map((p) => p === \"active-lts\" || p === \"maintenance-lts\"));\n\t}\n\n\t/**\n\t * Create a {@link NodeRelease} from lean string inputs.\n\t *\n\t * Parses `input.version` and `input.npm` via `SemVer.parse` and\n\t * constructs the publication date with `DateTime.unsafeMake`.\n\t *\n\t * @param input - A {@link NodeReleaseInput} object with raw string fields.\n\t * @param scheduleRef - A shared `Ref<NodeSchedule>` injected by the cache layer.\n\t * @returns An `Effect` that succeeds with a `NodeRelease` or fails with an\n\t *   `InvalidVersionError` when either version string cannot be parsed.\n\t */\n\tstatic fromInput(\n\t\tinput: NodeReleaseInput,\n\t\tscheduleRef: Ref.Ref<NodeSchedule>,\n\t): Effect.Effect<NodeRelease, InvalidVersionError> {\n\t\treturn Effect.gen(function* () {\n\t\t\tconst version = yield* SemVer.parse(input.version);\n\t\t\tconst npm = yield* SemVer.parse(input.npm);\n\t\t\tconst date = DateTime.unsafeMake(input.date);\n\t\t\treturn new NodeRelease(version, npm, date, scheduleRef);\n\t\t});\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAmBA,MAAa,mBAAmB,OAAO,OAAO;CAC7C,SAAS,OAAO;CAChB,KAAK,OAAO;CACZ,MAAM,OAAO;AACd,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DD,IAAa,cAAb,MAAa,YAAY;CAId;CACA;CACA;CACA;CANV,AAAS,OAAO;CAEhB,YACC,AAAS,SACT,AAAS,KACT,AAAS,MACT,AAAS,aACR;EAJQ;EACA;EACA;EACA;CACP;;;;;;;;;;;;;CAcH,MAAM,KAA0D;EAC/D,MAAM,eAAe,OAAO,SAAS,2BAAW,IAAI,KAAK,CAAC;EAC1D,OAAO,OAAO,IAAI,MAAM,aAAa;GAEpC,OAAO,QAAO,OADU,IAAI,IAAI,KAAK,WAAW,EAC1B,CAAC,SAAS,KAAK,QAAQ,OAAO,YAAY;EACjE,CAAC;CACF;;;;;;;;;CAUA,IAAI,KAAiD;EACpD,OAAO,KAAK,MAAM,GAAG,CAAC,CAAC,KAAK,OAAO,KAAK,MAAM,MAAM,gBAAgB,MAAM,iBAAiB,CAAC;CAC7F;;;;;;;;;;;;CAaA,OAAO,UACN,OACA,aACkD;EAClD,OAAO,OAAO,IAAI,aAAa;GAI9B,OAAO,IAAI,YAAY,OAHA,OAAO,MAAM,MAAM,OAAO,GAGjB,OAFb,OAAO,MAAM,MAAM,GAAG,GAC5B,SAAS,WAAW,MAAM,IACC,GAAG,WAAW;EACvD,CAAC;CACF;AACD"}

package/schemas/node-schedule.js

@@ -0,0 +1,111 @@
+import { Data, DateTime, Effect, Option } from "effect";
+
+//#region src/schemas/node-schedule.ts
+/**
+* Immutable snapshot of the Node.js release schedule.
+*
+* Holds a `ReadonlyArray<NodeScheduleEntry>` parsed from the raw
+* {@link NodeScheduleData} fetched by {@link NodeScheduleFetcher}. A single
+* `NodeSchedule` instance lives inside a `Ref<NodeSchedule>` that is shared
+* across all {@link NodeRelease} instances so that schedule updates propagate
+* without rebuilding the release cache.
+*
+* `NodeSchedule` extends `Data.TaggedClass` and therefore supports structural
+* equality — two schedules built from identical data compare as equal.
+*
+* @see {@link NodeRelease}
+* @see {@link NodeScheduleFetcher}
+*
+* @example
+* ```typescript
+* import { Effect } from "effect";
+* import type { NodePhase } from "./common.js";
+* import type { NodeScheduleData } from "./node-schedule.js";
+* import { NodeSchedule } from "./node-schedule.js";
+*
+* const data: NodeScheduleData = {
+*   v20: {
+*     start: "2023-04-18",
+*     lts: "2023-10-24",
+*     maintenance: "2024-10-22",
+*     end: "2026-04-30",
+*     codename: "Iron",
+*   },
+* };
+*
+* const schedule = NodeSchedule.fromData(data);
+*
+* const program = schedule.phaseFor(20, new Date("2024-01-01") as any).pipe(
+*   Effect.map((phase: NodePhase | null) => {
+*     console.log(phase); // "active-lts"
+*   }),
+* );
+*
+* Effect.runPromise(program);
+* ```
+*
+* @public
+*/
+var NodeSchedule = class NodeSchedule extends Data.TaggedClass("NodeSchedule") {
+	/**
+	* Parse raw {@link NodeScheduleData} into a `NodeSchedule` instance.
+	*
+	* Iterates over every key of the form `"vNN"`, converts ISO date strings
+	* to `DateTime.DateTime`, and normalises missing codenames to `""`.
+	*
+	* @param data - The raw JSON object fetched from the Node.js release repo.
+	* @returns A fully constructed, immutable `NodeSchedule`.
+	*/
+	static fromData(data) {
+		const entries = [];
+		for (const [key, value] of Object.entries(data)) {
+			const major = Number.parseInt(key.replace("v", ""), 10);
+			if (Number.isNaN(major)) continue;
+			entries.push({
+				major,
+				start: DateTime.unsafeMake(value.start),
+				lts: value.lts ? DateTime.unsafeMake(value.lts) : null,
+				maintenance: value.maintenance ? DateTime.unsafeMake(value.maintenance) : null,
+				end: DateTime.unsafeMake(value.end),
+				codename: value.codename ?? ""
+			});
+		}
+		return new NodeSchedule({ entries });
+	}
+	/**
+	* Determine the current {@link NodePhase} for a given major version number
+	* at the specified point in time.
+	*
+	* Returns `null` when the major is not present in the schedule or when
+	* `now` is before the release's start date.
+	*
+	* @param major - The Node.js major version number (e.g. `20`).
+	* @param now - The reference `DateTime` against which phases are evaluated.
+	*/
+	phaseFor(major, now) {
+		return Effect.sync(() => {
+			const entry = this.entries.find((e) => e.major === major);
+			if (!entry) return null;
+			if (DateTime.lessThan(now, entry.start)) return null;
+			if (DateTime.greaterThanOrEqualTo(now, entry.end)) return "end-of-life";
+			if (entry.maintenance && DateTime.greaterThanOrEqualTo(now, entry.maintenance)) return "maintenance-lts";
+			if (entry.lts && DateTime.greaterThanOrEqualTo(now, entry.lts)) return "active-lts";
+			return "current";
+		});
+	}
+	/**
+	* Look up the {@link NodeScheduleEntry} for a given major version number.
+	*
+	* Returns `Option.none()` when the major is not present in the schedule.
+	*
+	* @param major - The Node.js major version number (e.g. `20`).
+	*/
+	entryFor(major) {
+		const entry = this.entries.find((e) => e.major === major);
+		return entry ? Option.some(entry) : Option.none();
+	}
+};
+
+//#endregion
+export { NodeSchedule };
+//# sourceMappingURL=node-schedule.js.map

package/schemas/node-schedule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-schedule.js","names":[],"sources":["../../../../src/schemas/node-schedule.ts"],"sourcesContent":["import { Data, DateTime, Effect, Option } from \"effect\";\nimport type { NodePhase } from \"./common.js\";\n\n/**\n * A single entry in the Node.js release schedule, representing one major\n * release line's lifecycle dates and optional LTS codename.\n *\n * All date fields have already been converted from ISO strings to Effect\n * `DateTime.DateTime` values by {@link NodeSchedule.fromData}.\n *\n * @see {@link NodeSchedule}\n * @see {@link NodeSchedule.phaseFor}\n *\n * @public\n */\nexport interface NodeScheduleEntry {\n\treadonly major: number;\n\treadonly start: DateTime.DateTime;\n\treadonly lts: DateTime.DateTime | null;\n\treadonly maintenance: DateTime.DateTime | null;\n\treadonly end: DateTime.DateTime;\n\treadonly codename: string;\n}\n\n/**\n * Raw schedule format as fetched from the Node.js Release GitHub repository\n * (`nodejs/Release`).\n *\n * This is the intermediate type between the {@link NodeScheduleFetcher} layer\n * and the {@link NodeSchedule} class. Date values are plain ISO strings; the\n * `NodeSchedule.fromData` factory converts them to `DateTime`.\n *\n * @see {@link NodeSchedule.fromData}\n * @see {@link NodeScheduleFetcher}\n *\n * @public\n */\nexport type NodeScheduleData = Record<\n\tstring,\n\t{\n\t\treadonly start: string;\n\t\treadonly lts?: string;\n\t\treadonly maintenance?: string;\n\t\treadonly end: string;\n\t\treadonly codename?: string;\n\t}\n>;\n\n/**\n * Immutable snapshot of the Node.js release schedule.\n *\n * Holds a `ReadonlyArray<NodeScheduleEntry>` parsed from the raw\n * {@link NodeScheduleData} fetched by {@link NodeScheduleFetcher}. A single\n * `NodeSchedule` instance lives inside a `Ref<NodeSchedule>` that is shared\n * across all {@link NodeRelease} instances so that schedule updates propagate\n * without rebuilding the release cache.\n *\n * `NodeSchedule` extends `Data.TaggedClass` and therefore supports structural\n * equality — two schedules built from identical data compare as equal.\n *\n * @see {@link NodeRelease}\n * @see {@link NodeScheduleFetcher}\n *\n * @example\n * ```typescript\n * import { Effect } from \"effect\";\n * import type { NodePhase } from \"./common.js\";\n * import type { NodeScheduleData } from \"./node-schedule.js\";\n * import { NodeSchedule } from \"./node-schedule.js\";\n *\n * const data: NodeScheduleData = {\n *   v20: {\n *     start: \"2023-04-18\",\n *     lts: \"2023-10-24\",\n *     maintenance: \"2024-10-22\",\n *     end: \"2026-04-30\",\n *     codename: \"Iron\",\n *   },\n * };\n *\n * const schedule = NodeSchedule.fromData(data);\n *\n * const program = schedule.phaseFor(20, new Date(\"2024-01-01\") as any).pipe(\n *   Effect.map((phase: NodePhase | null) => {\n *     console.log(phase); // \"active-lts\"\n *   }),\n * );\n *\n * Effect.runPromise(program);\n * ```\n *\n * @public\n */\nexport class NodeSchedule extends Data.TaggedClass(\"NodeSchedule\")<{\n\treadonly entries: ReadonlyArray<NodeScheduleEntry>;\n}> {\n\t/**\n\t * Parse raw {@link NodeScheduleData} into a `NodeSchedule` instance.\n\t *\n\t * Iterates over every key of the form `\"vNN\"`, converts ISO date strings\n\t * to `DateTime.DateTime`, and normalises missing codenames to `\"\"`.\n\t *\n\t * @param data - The raw JSON object fetched from the Node.js release repo.\n\t * @returns A fully constructed, immutable `NodeSchedule`.\n\t */\n\tstatic fromData(data: NodeScheduleData): NodeSchedule {\n\t\tconst entries: NodeScheduleEntry[] = [];\n\t\tfor (const [key, value] of Object.entries(data)) {\n\t\t\tconst major = Number.parseInt(key.replace(\"v\", \"\"), 10);\n\t\t\tif (Number.isNaN(major)) continue;\n\t\t\tentries.push({\n\t\t\t\tmajor,\n\t\t\t\tstart: DateTime.unsafeMake(value.start),\n\t\t\t\tlts: value.lts ? DateTime.unsafeMake(value.lts) : null,\n\t\t\t\tmaintenance: value.maintenance ? DateTime.unsafeMake(value.maintenance) : null,\n\t\t\t\tend: DateTime.unsafeMake(value.end),\n\t\t\t\tcodename: value.codename ?? \"\",\n\t\t\t});\n\t\t}\n\t\treturn new NodeSchedule({ entries });\n\t}\n\n\t/**\n\t * Determine the current {@link NodePhase} for a given major version number\n\t * at the specified point in time.\n\t *\n\t * Returns `null` when the major is not present in the schedule or when\n\t * `now` is before the release's start date.\n\t *\n\t * @param major - The Node.js major version number (e.g. `20`).\n\t * @param now - The reference `DateTime` against which phases are evaluated.\n\t */\n\tphaseFor(major: number, now: DateTime.DateTime): Effect.Effect<NodePhase | null> {\n\t\treturn Effect.sync(() => {\n\t\t\tconst entry = this.entries.find((e) => e.major === major);\n\t\t\tif (!entry) return null;\n\n\t\t\tif (DateTime.lessThan(now, entry.start)) return null;\n\t\t\tif (DateTime.greaterThanOrEqualTo(now, entry.end)) return \"end-of-life\";\n\t\t\tif (entry.maintenance && DateTime.greaterThanOrEqualTo(now, entry.maintenance)) return \"maintenance-lts\";\n\t\t\tif (entry.lts && DateTime.greaterThanOrEqualTo(now, entry.lts)) return \"active-lts\";\n\t\t\treturn \"current\";\n\t\t});\n\t}\n\n\t/**\n\t * Look up the {@link NodeScheduleEntry} for a given major version number.\n\t *\n\t * Returns `Option.none()` when the major is not present in the schedule.\n\t *\n\t * @param major - The Node.js major version number (e.g. `20`).\n\t */\n\tentryFor(major: number): Option.Option<NodeScheduleEntry> {\n\t\tconst entry = this.entries.find((e) => e.major === major);\n\t\treturn entry ? Option.some(entry) : Option.none();\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6FA,IAAa,eAAb,MAAa,qBAAqB,KAAK,YAAY,cAAc,CAAC,CAE/D;;;;;;;;;;CAUF,OAAO,SAAS,MAAsC;EACrD,MAAM,UAA+B,CAAC;EACtC,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,IAAI,GAAG;GAChD,MAAM,QAAQ,OAAO,SAAS,IAAI,QAAQ,KAAK,EAAE,GAAG,EAAE;GACtD,IAAI,OAAO,MAAM,KAAK,GAAG;GACzB,QAAQ,KAAK;IACZ;IACA,OAAO,SAAS,WAAW,MAAM,KAAK;IACtC,KAAK,MAAM,MAAM,SAAS,WAAW,MAAM,GAAG,IAAI;IAClD,aAAa,MAAM,cAAc,SAAS,WAAW,MAAM,WAAW,IAAI;IAC1E,KAAK,SAAS,WAAW,MAAM,GAAG;IAClC,UAAU,MAAM,YAAY;GAC7B,CAAC;EACF;EACA,OAAO,IAAI,aAAa,EAAE,QAAQ,CAAC;CACpC;;;;;;;;;;;CAYA,SAAS,OAAe,KAAyD;EAChF,OAAO,OAAO,WAAW;GACxB,MAAM,QAAQ,KAAK,QAAQ,MAAM,MAAM,EAAE,UAAU,KAAK;GACxD,IAAI,CAAC,OAAO,OAAO;GAEnB,IAAI,SAAS,SAAS,KAAK,MAAM,KAAK,GAAG,OAAO;GAChD,IAAI,SAAS,qBAAqB,KAAK,MAAM,GAAG,GAAG,OAAO;GAC1D,IAAI,MAAM,eAAe,SAAS,qBAAqB,KAAK,MAAM,WAAW,GAAG,OAAO;GACvF,IAAI,MAAM,OAAO,SAAS,qBAAqB,KAAK,MAAM,GAAG,GAAG,OAAO;GACvE,OAAO;EACR,CAAC;CACF;;;;;;;;CASA,SAAS,OAAiD;EACzD,MAAM,QAAQ,KAAK,QAAQ,MAAM,MAAM,EAAE,UAAU,KAAK;EACxD,OAAO,QAAQ,OAAO,KAAK,KAAK,IAAI,OAAO,KAAK;CACjD;AACD"}

package/schemas/node.js

@@ -0,0 +1,69 @@
+import { Schema } from "effect";
+
+//#region src/schemas/node.ts
+/**
+* A single entry in the Node.js distribution index
+* (`https://nodejs.org/dist/index.json`).
+*
+* Decoded by {@link NodeVersionFetcherLive} when fetching the full list of
+* available Node.js releases from the official distribution server.
+*
+* @internal
+*/
+const NodeDistVersion = Schema.Struct({
+	version: Schema.String,
+	date: Schema.String,
+	files: Schema.Array(Schema.String),
+	npm: Schema.optional(Schema.String),
+	v8: Schema.optional(Schema.String),
+	uv: Schema.optional(Schema.String),
+	zlib: Schema.optional(Schema.String),
+	openssl: Schema.optional(Schema.String),
+	modules: Schema.optional(Schema.String),
+	lts: Schema.Union(Schema.Literal(false), Schema.String),
+	security: Schema.Boolean
+});
+/**
+* The full decoded body of `https://nodejs.org/dist/index.json`.
+*
+* Decoded by {@link NodeVersionFetcherLive} before being mapped into
+* {@link NodeRelease} instances.
+*
+* @internal
+*/
+const NodeDistIndex = Schema.Array(NodeDistVersion);
+/**
+* A single entry in the Node.js release schedule JSON fetched by
+* {@link NodeScheduleFetcherLive}.
+*
+* All date-like fields are optional because odd-numbered major lines
+* (e.g. v21) never enter LTS.
+*
+* @internal
+*/
+const ReleaseScheduleEntry = Schema.Struct({
+	start: Schema.String,
+	lts: Schema.optional(Schema.String),
+	maintenance: Schema.optional(Schema.String),
+	end: Schema.String,
+	codename: Schema.optional(Schema.String)
+});
+/**
+* The full decoded body of the Node.js release schedule JSON fetched by
+* {@link NodeScheduleFetcherLive}.
+*
+* Keyed by major version string (e.g. `"v20"`); values are
+* {@link ReleaseScheduleEntry} objects. After decoding, this record is handed
+* to {@link NodeSchedule.fromData} to produce an immutable
+* {@link NodeSchedule}.
+*
+* @internal
+*/
+const NodeReleaseSchedule = Schema.Record({
+	key: Schema.String,
+	value: ReleaseScheduleEntry
+});
+
+//#endregion
+export { NodeDistIndex, NodeReleaseSchedule };
+//# sourceMappingURL=node.js.map

package/schemas/node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.js","names":[],"sources":["../../../../src/schemas/node.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\n/**\n * A single entry in the Node.js distribution index\n * (`https://nodejs.org/dist/index.json`).\n *\n * Decoded by {@link NodeVersionFetcherLive} when fetching the full list of\n * available Node.js releases from the official distribution server.\n *\n * @internal\n */\nexport const NodeDistVersion = Schema.Struct({\n\tversion: Schema.String,\n\tdate: Schema.String,\n\tfiles: Schema.Array(Schema.String),\n\tnpm: Schema.optional(Schema.String),\n\tv8: Schema.optional(Schema.String),\n\tuv: Schema.optional(Schema.String),\n\tzlib: Schema.optional(Schema.String),\n\topenssl: Schema.optional(Schema.String),\n\tmodules: Schema.optional(Schema.String),\n\tlts: Schema.Union(Schema.Literal(false), Schema.String),\n\tsecurity: Schema.Boolean,\n});\n\n/**\n * The decoded type of a single entry in the Node.js distribution index.\n *\n * @internal\n */\nexport type NodeDistVersion = typeof NodeDistVersion.Type;\n\n/**\n * The full decoded body of `https://nodejs.org/dist/index.json`.\n *\n * Decoded by {@link NodeVersionFetcherLive} before being mapped into\n * {@link NodeRelease} instances.\n *\n * @internal\n */\nexport const NodeDistIndex = Schema.Array(NodeDistVersion);\n\n/**\n * The full decoded body of `https://nodejs.org/dist/index.json`.\n *\n * @internal\n */\nexport type NodeDistIndex = typeof NodeDistIndex.Type;\n\n/**\n * A single entry in the Node.js release schedule JSON fetched by\n * {@link NodeScheduleFetcherLive}.\n *\n * All date-like fields are optional because odd-numbered major lines\n * (e.g. v21) never enter LTS.\n *\n * @internal\n */\nexport const ReleaseScheduleEntry = Schema.Struct({\n\tstart: Schema.String,\n\tlts: Schema.optional(Schema.String),\n\tmaintenance: Schema.optional(Schema.String),\n\tend: Schema.String,\n\tcodename: Schema.optional(Schema.String),\n});\n\n/**\n * The decoded type of a single entry in the Node.js release schedule JSON.\n *\n * @internal\n */\nexport type ReleaseScheduleEntry = typeof ReleaseScheduleEntry.Type;\n\n/**\n * The full decoded body of the Node.js release schedule JSON fetched by\n * {@link NodeScheduleFetcherLive}.\n *\n * Keyed by major version string (e.g. `\"v20\"`); values are\n * {@link ReleaseScheduleEntry} objects. After decoding, this record is handed\n * to {@link NodeSchedule.fromData} to produce an immutable\n * {@link NodeSchedule}.\n *\n * @internal\n */\nexport const NodeReleaseSchedule = Schema.Record({\n\tkey: Schema.String,\n\tvalue: ReleaseScheduleEntry,\n});\n\n/**\n * The full decoded type of the Node.js release schedule JSON.\n *\n * @internal\n */\nexport type NodeReleaseSchedule = typeof NodeReleaseSchedule.Type;\n"],"mappings":";;;;;;;;;;;;AAWA,MAAa,kBAAkB,OAAO,OAAO;CAC5C,SAAS,OAAO;CAChB,MAAM,OAAO;CACb,OAAO,OAAO,MAAM,OAAO,MAAM;CACjC,KAAK,OAAO,SAAS,OAAO,MAAM;CAClC,IAAI,OAAO,SAAS,OAAO,MAAM;CACjC,IAAI,OAAO,SAAS,OAAO,MAAM;CACjC,MAAM,OAAO,SAAS,OAAO,MAAM;CACnC,SAAS,OAAO,SAAS,OAAO,MAAM;CACtC,SAAS,OAAO,SAAS,OAAO,MAAM;CACtC,KAAK,OAAO,MAAM,OAAO,QAAQ,KAAK,GAAG,OAAO,MAAM;CACtD,UAAU,OAAO;AAClB,CAAC;;;;;;;;;AAiBD,MAAa,gBAAgB,OAAO,MAAM,eAAe;;;;;;;;;;AAkBzD,MAAa,uBAAuB,OAAO,OAAO;CACjD,OAAO,OAAO;CACd,KAAK,OAAO,SAAS,OAAO,MAAM;CAClC,aAAa,OAAO,SAAS,OAAO,MAAM;CAC1C,KAAK,OAAO;CACZ,UAAU,OAAO,SAAS,OAAO,MAAM;AACxC,CAAC;;;;;;;;;;;;AAoBD,MAAa,sBAAsB,OAAO,OAAO;CAChD,KAAK,OAAO;CACZ,OAAO;AACR,CAAC"}

package/services/BunReleaseCache.js

@@ -0,0 +1,34 @@
+import { Context } from "effect";
+
+//#region src/services/BunReleaseCache.ts
+/**
+* Specialisation of {@link RuntimeCache} for Bun release objects.
+*
+* @example
+* ```typescript
+* import type { BunRelease } from "runtime-resolver";
+* import { BunReleaseCache, OfflineBunCacheLive } from "runtime-resolver";
+* import { Effect } from "effect";
+*
+* const program = Effect.gen(function* () {
+* 	const cache = yield* BunReleaseCache;
+* 	const releases = yield* cache.releases();
+* 	console.log(releases.length);
+* });
+*
+* Effect.runPromise(program.pipe(Effect.provide(OfflineBunCacheLive)));
+* ```
+*
+* @see {@link BunRelease}
+* @see {@link RuntimeCache}
+* @see {@link AutoBunCacheLive}
+* @see {@link FreshBunCacheLive}
+* @see {@link OfflineBunCacheLive}
+*
+* @public
+*/
+var BunReleaseCache = class extends Context.Tag("runtime-resolver/BunReleaseCache")() {};
+
+//#endregion
+export { BunReleaseCache };
+//# sourceMappingURL=BunReleaseCache.js.map

package/services/BunReleaseCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BunReleaseCache.js","names":[],"sources":["../../../../src/services/BunReleaseCache.ts"],"sourcesContent":["import { Context } from \"effect\";\nimport type { BunRelease } from \"../schemas/bun-release.js\";\nimport type { RuntimeCache } from \"./RuntimeCache.js\";\n\n/**\n * Specialisation of {@link RuntimeCache} for Bun release objects.\n *\n * @example\n * ```typescript\n * import type { BunRelease } from \"runtime-resolver\";\n * import { BunReleaseCache, OfflineBunCacheLive } from \"runtime-resolver\";\n * import { Effect } from \"effect\";\n *\n * const program = Effect.gen(function* () {\n * \tconst cache = yield* BunReleaseCache;\n * \tconst releases = yield* cache.releases();\n * \tconsole.log(releases.length);\n * });\n *\n * Effect.runPromise(program.pipe(Effect.provide(OfflineBunCacheLive)));\n * ```\n *\n * @see {@link BunRelease}\n * @see {@link RuntimeCache}\n * @see {@link AutoBunCacheLive}\n * @see {@link FreshBunCacheLive}\n * @see {@link OfflineBunCacheLive}\n *\n * @public\n */\nexport class BunReleaseCache extends Context.Tag(\"runtime-resolver/BunReleaseCache\")<\n\tBunReleaseCache,\n\tRuntimeCache<BunRelease>\n>() {}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,IAAa,kBAAb,cAAqC,QAAQ,IAAI,kCAAkC,CAAC,CAGlF,CAAC,CAAC,CAAC"}

package/services/BunResolver.js

@@ -0,0 +1,37 @@
+import { Context } from "effect";
+
+//#region src/services/BunResolver.ts
+/**
+* Service for resolving Bun runtime versions against the cached
+* release index.
+*
+* For a one-shot Promise-based API see {@link resolveBun}.
+*
+* @example
+* ```typescript
+* import type { ResolvedVersions } from "runtime-resolver";
+* import { BunResolver, BunResolverLive } from "runtime-resolver";
+* import { Effect } from "effect";
+*
+* const program = Effect.gen(function* () {
+* 	const resolver = yield* BunResolver;
+* 	const result = yield* resolver.resolve({ semverRange: "^1.0.0", increments: "minor" });
+* 	console.log(result.latest);
+* 	console.log(result.versions);
+* });
+*
+* Effect.runPromise(program.pipe(Effect.provide(BunResolverLive)));
+* ```
+*
+* @see {@link BunResolverLive}
+* @see {@link resolveBun}
+* @see {@link BunResolverOptions}
+* @see {@link ResolvedVersions}
+*
+* @public
+*/
+var BunResolver = class extends Context.Tag("runtime-resolver/BunResolver")() {};
+
+//#endregion
+export { BunResolver };
+//# sourceMappingURL=BunResolver.js.map

package/services/BunResolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BunResolver.js","names":[],"sources":["../../../../src/services/BunResolver.ts"],"sourcesContent":["import type { Effect } from \"effect\";\nimport { Context } from \"effect\";\nimport type { VersionNotFoundError } from \"../errors/VersionNotFoundError.js\";\nimport type { Increments, ResolvedVersions } from \"../schemas/common.js\";\n\n/**\n * Options accepted by {@link BunResolver.resolve}.\n *\n * All fields are optional; omitting them causes the resolver to fall back to\n * its built-in defaults (latest stable release, `\"latest\"` increment\n * granularity).\n *\n * @see {@link BunResolver}\n * @see {@link Increments}\n * @see {@link ResolvedVersions}\n *\n * @public\n */\nexport interface BunResolverOptions {\n\t/**\n\t * A semver range string used to constrain which Bun releases are\n\t * considered (e.g. `\"^1.0.0\"` or `\">=1.1.0 <2.0.0\"`).\n\t *\n\t * When omitted all cached releases are eligible.\n\t */\n\treadonly semverRange?: string;\n\n\t/**\n\t * A fallback version string returned when no release satisfies\n\t * `semverRange`. Must be a valid semver version (e.g. `\"1.0.0\"`).\n\t *\n\t * When omitted and no match is found the effect fails with\n\t * {@link VersionNotFoundError}.\n\t */\n\treadonly defaultVersion?: string;\n\n\t/**\n\t * Controls the granularity of the version list included in\n\t * {@link ResolvedVersions.versions}.\n\t *\n\t * - `\"latest\"` — only the single highest matching version.\n\t * - `\"minor\"` — the latest patch for every minor line.\n\t * - `\"patch\"` — every individual patch release.\n\t *\n\t * Defaults to `\"latest\"` when omitted.\n\t *\n\t * @see {@link Increments}\n\t */\n\treadonly increments?: Increments;\n}\n\n/**\n * Union of all typed errors that {@link BunResolver.resolve} can fail with.\n *\n * @see {@link VersionNotFoundError}\n *\n * @public\n */\nexport type BunResolverError = VersionNotFoundError;\n\n/**\n * Service for resolving Bun runtime versions against the cached\n * release index.\n *\n * For a one-shot Promise-based API see {@link resolveBun}.\n *\n * @example\n * ```typescript\n * import type { ResolvedVersions } from \"runtime-resolver\";\n * import { BunResolver, BunResolverLive } from \"runtime-resolver\";\n * import { Effect } from \"effect\";\n *\n * const program = Effect.gen(function* () {\n * \tconst resolver = yield* BunResolver;\n * \tconst result = yield* resolver.resolve({ semverRange: \"^1.0.0\", increments: \"minor\" });\n * \tconsole.log(result.latest);\n * \tconsole.log(result.versions);\n * });\n *\n * Effect.runPromise(program.pipe(Effect.provide(BunResolverLive)));\n * ```\n *\n * @see {@link BunResolverLive}\n * @see {@link resolveBun}\n * @see {@link BunResolverOptions}\n * @see {@link ResolvedVersions}\n *\n * @public\n */\nexport class BunResolver extends Context.Tag(\"runtime-resolver/BunResolver\")<\n\tBunResolver,\n\t{\n\t\t/**\n\t\t * Resolves Bun versions according to `options` and returns a\n\t\t * {@link ResolvedVersions} object containing the matching version list,\n\t\t * the latest version string, and the data source indicator.\n\t\t *\n\t\t * Fails with {@link BunResolverError} when no version can be resolved and\n\t\t * no `defaultVersion` was provided.\n\t\t *\n\t\t * @param options - Optional resolution constraints.\n\t\t *\n\t\t * @see {@link BunResolverOptions}\n\t\t */\n\t\treadonly resolve: (options?: BunResolverOptions) => Effect.Effect<ResolvedVersions, BunResolverError>;\n\t}\n>() {}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyFA,IAAa,cAAb,cAAiC,QAAQ,IAAI,8BAA8B,CAAC,CAiB1E,CAAC,CAAC,CAAC"}

package/services/BunVersionFetcher.js

@@ -0,0 +1,42 @@
+import { Context } from "effect";
+
+//#region src/services/BunVersionFetcher.ts
+/**
+* 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}
+* @see {@link NetworkError}
+* @see {@link ParseError}
+* @see {@link RateLimitError}
+*
+* @public
+*/
+var BunVersionFetcher = class extends Context.Tag("runtime-resolver/BunVersionFetcher")() {};
+
+//#endregion
+export { BunVersionFetcher };
+//# sourceMappingURL=BunVersionFetcher.js.map

package/services/BunVersionFetcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BunVersionFetcher.js","names":[],"sources":["../../../../src/services/BunVersionFetcher.ts"],"sourcesContent":["import type { Effect } from \"effect\";\nimport { Context } from \"effect\";\nimport type { SemVer } from \"semver-effect\";\nimport type { AuthenticationError } from \"../errors/AuthenticationError.js\";\nimport type { NetworkError } from \"../errors/NetworkError.js\";\nimport type { ParseError } from \"../errors/ParseError.js\";\nimport type { RateLimitError } from \"../errors/RateLimitError.js\";\nimport type { RuntimeReleaseInput } from \"../schemas/runtime-release.js\";\n\n/**\n * Service for fetching Bun release data from the GitHub API.\n *\n * Retrieves both the parsed semver version list and the raw release input\n * records needed to populate a {@link BunReleaseCache}. The live\n * implementation queries the `oven-sh/bun` GitHub repository via\n * {@link GitHubClient}.\n *\n * @example\n * ```typescript\n * import type { RuntimeReleaseInput } from \"runtime-resolver\";\n * import { BunVersionFetcher, BunVersionFetcherLive, GitHubAutoAuth } from \"runtime-resolver\";\n * import { Effect } from \"effect\";\n *\n * const program = Effect.gen(function* () {\n * \tconst fetcher = yield* BunVersionFetcher;\n * \tconst { versions, inputs } = yield* fetcher.fetch();\n * \tconsole.log(`Fetched ${versions.length} Bun releases`);\n * });\n *\n * Effect.runPromise(\n * \tprogram.pipe(Effect.provide(BunVersionFetcherLive), Effect.provide(GitHubAutoAuth)),\n * );\n * ```\n *\n * @see {@link BunVersionFetcherLive}\n * @see {@link BunReleaseCache}\n * @see {@link AuthenticationError}\n * @see {@link NetworkError}\n * @see {@link ParseError}\n * @see {@link RateLimitError}\n *\n * @public\n */\nexport class BunVersionFetcher extends Context.Tag(\"runtime-resolver/BunVersionFetcher\")<\n\tBunVersionFetcher,\n\t{\n\t\t/**\n\t\t * Fetches all available Bun releases from the GitHub API and returns both\n\t\t * the parsed semver version objects and the raw release input records.\n\t\t *\n\t\t * Fails with:\n\t\t * - {@link AuthenticationError} — missing or invalid GitHub credentials.\n\t\t * - {@link NetworkError} — the upstream request could not be completed.\n\t\t * - {@link ParseError} — the response payload could not be decoded.\n\t\t * - {@link RateLimitError} — the GitHub API rate limit was exceeded.\n\t\t */\n\t\treadonly fetch: () => Effect.Effect<\n\t\t\t{\n\t\t\t\treadonly versions: ReadonlyArray<SemVer>;\n\t\t\t\treadonly inputs: ReadonlyArray<RuntimeReleaseInput>;\n\t\t\t},\n\t\t\tAuthenticationError | NetworkError | ParseError | RateLimitError\n\t\t>;\n\t}\n>() {}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,IAAa,oBAAb,cAAuC,QAAQ,IAAI,oCAAoC,CAAC,CAqBtF,CAAC,CAAC,CAAC"}

package/services/DenoReleaseCache.js

@@ -0,0 +1,34 @@
+import { Context } from "effect";
+
+//#region src/services/DenoReleaseCache.ts
+/**
+* Specialisation of {@link RuntimeCache} for Deno release objects.
+*
+* @example
+* ```typescript
+* import type { DenoRelease } from "runtime-resolver";
+* import { DenoReleaseCache, OfflineDenoCacheLive } from "runtime-resolver";
+* import { Effect } from "effect";
+*
+* const program = Effect.gen(function* () {
+* 	const cache = yield* DenoReleaseCache;
+* 	const latest = yield* cache.latest();
+* 	console.log(latest.version.toString());
+* });
+*
+* Effect.runPromise(program.pipe(Effect.provide(OfflineDenoCacheLive)));
+* ```
+*
+* @see {@link DenoRelease}
+* @see {@link RuntimeCache}
+* @see {@link AutoDenoCacheLive}
+* @see {@link FreshDenoCacheLive}
+* @see {@link OfflineDenoCacheLive}
+*
+* @public
+*/
+var DenoReleaseCache = class extends Context.Tag("runtime-resolver/DenoReleaseCache")() {};
+
+//#endregion
+export { DenoReleaseCache };
+//# sourceMappingURL=DenoReleaseCache.js.map

package/services/DenoReleaseCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DenoReleaseCache.js","names":[],"sources":["../../../../src/services/DenoReleaseCache.ts"],"sourcesContent":["import { Context } from \"effect\";\nimport type { DenoRelease } from \"../schemas/deno-release.js\";\nimport type { RuntimeCache } from \"./RuntimeCache.js\";\n\n/**\n * Specialisation of {@link RuntimeCache} for Deno release objects.\n *\n * @example\n * ```typescript\n * import type { DenoRelease } from \"runtime-resolver\";\n * import { DenoReleaseCache, OfflineDenoCacheLive } from \"runtime-resolver\";\n * import { Effect } from \"effect\";\n *\n * const program = Effect.gen(function* () {\n * \tconst cache = yield* DenoReleaseCache;\n * \tconst latest = yield* cache.latest();\n * \tconsole.log(latest.version.toString());\n * });\n *\n * Effect.runPromise(program.pipe(Effect.provide(OfflineDenoCacheLive)));\n * ```\n *\n * @see {@link DenoRelease}\n * @see {@link RuntimeCache}\n * @see {@link AutoDenoCacheLive}\n * @see {@link FreshDenoCacheLive}\n * @see {@link OfflineDenoCacheLive}\n *\n * @public\n */\nexport class DenoReleaseCache extends Context.Tag(\"runtime-resolver/DenoReleaseCache\")<\n\tDenoReleaseCache,\n\tRuntimeCache<DenoRelease>\n>() {}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,IAAa,mBAAb,cAAsC,QAAQ,IAAI,mCAAmC,CAAC,CAGpF,CAAC,CAAC,CAAC"}

package/services/DenoResolver.js

@@ -0,0 +1,37 @@
+import { Context } from "effect";
+
+//#region src/services/DenoResolver.ts
+/**
+* Service for resolving Deno runtime versions against the cached
+* release index.
+*
+* For a one-shot Promise-based API see {@link resolveDeno}.
+*
+* @example
+* ```typescript
+* import type { ResolvedVersions } from "runtime-resolver";
+* import { DenoResolver, DenoResolverLive } from "runtime-resolver";
+* import { Effect } from "effect";
+*
+* const program = Effect.gen(function* () {
+* 	const resolver = yield* DenoResolver;
+* 	const result = yield* resolver.resolve({ semverRange: "^2.0.0", increments: "minor" });
+* 	console.log(result.latest);
+* 	console.log(result.versions);
+* });
+*
+* Effect.runPromise(program.pipe(Effect.provide(DenoResolverLive)));
+* ```
+*
+* @see {@link DenoResolverLive}
+* @see {@link resolveDeno}
+* @see {@link DenoResolverOptions}
+* @see {@link ResolvedVersions}
+*
+* @public
+*/
+var DenoResolver = class extends Context.Tag("runtime-resolver/DenoResolver")() {};
+
+//#endregion
+export { DenoResolver };
+//# sourceMappingURL=DenoResolver.js.map