runtime-resolver 0.3.12 → 0.3.14

package/schemas/bun-release.js

@@ -0,0 +1,61 @@
+import { Data, DateTime, Effect } from "effect";
+import { SemVer } from "semver-effect";
+
+//#region src/schemas/bun-release.ts
+/**
+* A Bun release entry with a parsed {@link SemVer} version and an
+* Effect {@link DateTime.DateTime} publication date.
+*
+* `BunRelease` extends `Data.TaggedClass` so instances support structural
+* equality comparison and can be used safely inside Effect data structures.
+* Construct instances via the {@link BunRelease.fromInput} factory rather than
+* calling `new BunRelease(...)` directly, as the factory validates the version
+* string through `SemVer.parse`.
+*
+* @see {@link BunReleaseCache}
+* @see {@link BunResolver}
+* @see {@link 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 {@link 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* () {
+			return new BunRelease({
+				version: yield* SemVer.parse(input.version),
+				date: input.date ? DateTime.unsafeMake(input.date) : DateTime.unsafeMake(/* @__PURE__ */ new Date())
+			});
+		});
+	}
+};
+
+//#endregion
+export { BunRelease };

package/schemas/deno-release.js

@@ -0,0 +1,61 @@
+import { Data, DateTime, Effect } from "effect";
+import { SemVer } from "semver-effect";
+
+//#region src/schemas/deno-release.ts
+/**
+* A Deno release entry with a parsed {@link SemVer} version and an
+* Effect {@link DateTime.DateTime} publication date.
+*
+* `DenoRelease` extends `Data.TaggedClass` so instances support structural
+* equality comparison and can be used safely inside Effect data structures.
+* Construct instances via the {@link DenoRelease.fromInput} factory rather than
+* calling `new DenoRelease(...)` directly, as the factory validates the version
+* string through `SemVer.parse`.
+*
+* @see {@link DenoReleaseCache}
+* @see {@link DenoResolver}
+* @see {@link 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 {@link 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* () {
+			return new DenoRelease({
+				version: yield* SemVer.parse(input.version),
+				date: input.date ? DateTime.unsafeMake(input.date) : DateTime.unsafeMake(/* @__PURE__ */ new Date())
+			});
+		});
+	}
+};
+
+//#endregion
+export { DenoRelease };

package/schemas/github.js

@@ -0,0 +1,74 @@
+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 };

package/schemas/node-release.js

@@ -0,0 +1,130 @@
+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 };

package/schemas/node-schedule.js

@@ -0,0 +1,110 @@
+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 };

package/schemas/node.js

@@ -0,0 +1,68 @@
+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 };

package/services/BunReleaseCache.js

@@ -0,0 +1,33 @@
+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 };

package/services/BunResolver.js

@@ -0,0 +1,36 @@
+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 };

package/services/BunVersionFetcher.js

@@ -0,0 +1,41 @@
+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 };

package/services/DenoReleaseCache.js

@@ -0,0 +1,33 @@
+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 };

package/services/DenoResolver.js

@@ -0,0 +1,36 @@
+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 };