runtime-resolver 0.3.12 → 0.3.13

package/layers/OfflineBunCacheLive.js

@@ -0,0 +1,41 @@
+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 };
+//# sourceMappingURL=OfflineBunCacheLive.js.map

package/layers/OfflineBunCacheLive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OfflineBunCacheLive.js","names":["SemVerVersionCacheLive"],"sources":["../../../../src/layers/OfflineBunCacheLive.ts"],"sourcesContent":["import { Effect, Layer } from \"effect\";\nimport { SemVerParserLive, VersionCacheLive as SemVerVersionCacheLive } from \"semver-effect\";\nimport { bunDefaultInputs } from \"../data/bun-defaults.js\";\nimport { BunRelease } from \"../schemas/bun-release.js\";\nimport { BunReleaseCache } from \"../services/BunReleaseCache.js\";\nimport { BunReleaseCacheLive } from \"./BunReleaseCacheLive.js\";\n\nconst offlineSetup = Effect.gen(function* () {\n\tconst cache = yield* BunReleaseCache;\n\tconst releases = yield* Effect.all(\n\t\tbunDefaultInputs.map((input) => BunRelease.fromInput(input)),\n\t\t{ concurrency: \"unbounded\" },\n\t).pipe(Effect.orElseSucceed(() => [] as BunRelease[]));\n\tyield* cache.load(releases);\n});\n\nconst SemVerLayer = SemVerVersionCacheLive.pipe(Layer.provide(SemVerParserLive));\nconst BaseCacheLayer = BunReleaseCacheLive.pipe(Layer.provide(SemVerLayer));\n\n/**\n * Provides the {@link BunReleaseCache} service using the \"Offline\" cache strategy.\n *\n * Uses only the bundled default Bun release data that was baked in at build time.\n * Makes no network requests and has no runtime dependencies. This layer always\n * succeeds immediately.\n *\n * Use this strategy in environments where network access is unavailable or\n * undesirable (e.g., air-gapped systems, hermetic test environments, or any\n * context where version data from the bundle is sufficient).\n *\n * The three Bun cache strategy layers are:\n * - {@link AutoBunCacheLive} — tries API first, falls back to bundled defaults on any error\n * - {@link FreshBunCacheLive} — requires live API data, fails with `FreshnessError` if unavailable\n * - `OfflineBunCacheLive` — uses only bundled defaults, no network I/O\n *\n * @see {@link BunReleaseCache}\n * @see {@link AutoBunCacheLive}\n * @see {@link FreshBunCacheLive}\n * @public\n */\nexport const OfflineBunCacheLive: Layer.Layer<BunReleaseCache> = BaseCacheLayer.pipe(\n\tLayer.tap((ctx) => offlineSetup.pipe(Effect.provide(ctx))),\n);\n"],"mappings":";;;;;;;;AAOA,MAAM,eAAe,OAAO,IAAI,aAAa;CAC5C,MAAM,QAAQ,OAAO;CACrB,MAAM,WAAW,OAAO,OAAO,IAC9B,iBAAiB,KAAK,UAAU,WAAW,UAAU,KAAK,CAAC,GAC3D,EAAE,aAAa,YAAY,CAC5B,CAAC,CAAC,KAAK,OAAO,oBAAoB,CAAC,CAAiB,CAAC;CACrD,OAAO,MAAM,KAAK,QAAQ;AAC3B,CAAC;AAED,MAAM,cAAcA,iBAAuB,KAAK,MAAM,QAAQ,gBAAgB,CAAC;AAC/E,MAAM,iBAAiB,oBAAoB,KAAK,MAAM,QAAQ,WAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;AAuB1E,MAAa,sBAAoD,eAAe,KAC/E,MAAM,KAAK,QAAQ,aAAa,KAAK,OAAO,QAAQ,GAAG,CAAC,CAAC,CAC1D"}

package/layers/OfflineDenoCacheLive.js

@@ -0,0 +1,41 @@
+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 };
+//# sourceMappingURL=OfflineDenoCacheLive.js.map

package/layers/OfflineDenoCacheLive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OfflineDenoCacheLive.js","names":["SemVerVersionCacheLive"],"sources":["../../../../src/layers/OfflineDenoCacheLive.ts"],"sourcesContent":["import { Effect, Layer } from \"effect\";\nimport { SemVerParserLive, VersionCacheLive as SemVerVersionCacheLive } from \"semver-effect\";\nimport { denoDefaultInputs } from \"../data/deno-defaults.js\";\nimport { DenoRelease } from \"../schemas/deno-release.js\";\nimport { DenoReleaseCache } from \"../services/DenoReleaseCache.js\";\nimport { DenoReleaseCacheLive } from \"./DenoReleaseCacheLive.js\";\n\nconst offlineSetup = Effect.gen(function* () {\n\tconst cache = yield* DenoReleaseCache;\n\tconst releases = yield* Effect.all(\n\t\tdenoDefaultInputs.map((input) => DenoRelease.fromInput(input)),\n\t\t{ concurrency: \"unbounded\" },\n\t).pipe(Effect.orElseSucceed(() => [] as DenoRelease[]));\n\tyield* cache.load(releases);\n});\n\nconst SemVerLayer = SemVerVersionCacheLive.pipe(Layer.provide(SemVerParserLive));\nconst BaseCacheLayer = DenoReleaseCacheLive.pipe(Layer.provide(SemVerLayer));\n\n/**\n * Provides the {@link DenoReleaseCache} service using the \"Offline\" cache strategy.\n *\n * Uses only the bundled default Deno release data that was baked in at build time.\n * Makes no network requests and has no runtime dependencies. This layer always\n * succeeds immediately.\n *\n * Use this strategy in environments where network access is unavailable or\n * undesirable (e.g., air-gapped systems, hermetic test environments, or any\n * context where version data from the bundle is sufficient).\n *\n * The three Deno cache strategy layers are:\n * - {@link AutoDenoCacheLive} — tries API first, falls back to bundled defaults on any error\n * - {@link FreshDenoCacheLive} — requires live API data, fails with `FreshnessError` if unavailable\n * - `OfflineDenoCacheLive` — uses only bundled defaults, no network I/O\n *\n * @see {@link DenoReleaseCache}\n * @see {@link AutoDenoCacheLive}\n * @see {@link FreshDenoCacheLive}\n * @public\n */\nexport const OfflineDenoCacheLive: Layer.Layer<DenoReleaseCache> = BaseCacheLayer.pipe(\n\tLayer.tap((ctx) => offlineSetup.pipe(Effect.provide(ctx))),\n);\n"],"mappings":";;;;;;;;AAOA,MAAM,eAAe,OAAO,IAAI,aAAa;CAC5C,MAAM,QAAQ,OAAO;CACrB,MAAM,WAAW,OAAO,OAAO,IAC9B,kBAAkB,KAAK,UAAU,YAAY,UAAU,KAAK,CAAC,GAC7D,EAAE,aAAa,YAAY,CAC5B,CAAC,CAAC,KAAK,OAAO,oBAAoB,CAAC,CAAkB,CAAC;CACtD,OAAO,MAAM,KAAK,QAAQ;AAC3B,CAAC;AAED,MAAM,cAAcA,iBAAuB,KAAK,MAAM,QAAQ,gBAAgB,CAAC;AAC/E,MAAM,iBAAiB,qBAAqB,KAAK,MAAM,QAAQ,WAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;AAuB3E,MAAa,uBAAsD,eAAe,KACjF,MAAM,KAAK,QAAQ,aAAa,KAAK,OAAO,QAAQ,GAAG,CAAC,CAAC,CAC1D"}

package/layers/OfflineNodeCacheLive.js

@@ -0,0 +1,40 @@
+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 };
+//# sourceMappingURL=OfflineNodeCacheLive.js.map

package/layers/OfflineNodeCacheLive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OfflineNodeCacheLive.js","names":["SemVerVersionCacheLive"],"sources":["../../../../src/layers/OfflineNodeCacheLive.ts"],"sourcesContent":["import { Effect, Layer } from \"effect\";\nimport { SemVerParserLive, VersionCacheLive as SemVerVersionCacheLive } from \"semver-effect\";\nimport { nodeDefaultInputs, nodeDefaultScheduleData } from \"../data/node-defaults.js\";\nimport { NodeReleaseCache } from \"../services/NodeReleaseCache.js\";\nimport { NodeReleaseCacheLive } from \"./NodeReleaseCacheLive.js\";\n\nconst offlineSetup = Effect.gen(function* () {\n\tconst cache = yield* NodeReleaseCache;\n\tyield* cache.updateSchedule(nodeDefaultScheduleData);\n\tyield* cache.loadFromInputs(nodeDefaultInputs);\n});\n\nconst SemVerLayer = SemVerVersionCacheLive.pipe(Layer.provide(SemVerParserLive));\nconst BaseCacheLayer = NodeReleaseCacheLive.pipe(Layer.provide(SemVerLayer));\n\n/**\n * Provides the {@link NodeReleaseCache} service using the \"Offline\" cache strategy.\n *\n * Uses only the bundled default Node.js release data and schedule data that were\n * baked in at build time. Makes no network requests and has no runtime\n * dependencies. This layer always succeeds immediately.\n *\n * Use this strategy in environments where network access is unavailable or\n * undesirable (e.g., air-gapped systems, hermetic test environments, or any\n * context where version data from the bundle is sufficient).\n *\n * The three Node cache strategy layers are:\n * - {@link AutoNodeCacheLive} — tries API first, falls back to bundled defaults on any error\n * - {@link FreshNodeCacheLive} — requires live API data, fails with `FreshnessError` if unavailable\n * - `OfflineNodeCacheLive` — uses only bundled defaults, no network I/O\n *\n * @see {@link NodeReleaseCache}\n * @see {@link AutoNodeCacheLive}\n * @see {@link FreshNodeCacheLive}\n * @public\n */\nexport const OfflineNodeCacheLive: Layer.Layer<NodeReleaseCache> = BaseCacheLayer.pipe(\n\tLayer.tap((ctx) => offlineSetup.pipe(Effect.provide(ctx))),\n);\n"],"mappings":";;;;;;;AAMA,MAAM,eAAe,OAAO,IAAI,aAAa;CAC5C,MAAM,QAAQ,OAAO;CACrB,OAAO,MAAM,eAAe,uBAAuB;CACnD,OAAO,MAAM,eAAe,iBAAiB;AAC9C,CAAC;AAED,MAAM,cAAcA,iBAAuB,KAAK,MAAM,QAAQ,gBAAgB,CAAC;AAC/E,MAAM,iBAAiB,qBAAqB,KAAK,MAAM,QAAQ,WAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;AAuB3E,MAAa,uBAAsD,eAAe,KACjF,MAAM,KAAK,QAAQ,aAAa,KAAK,OAAO,QAAQ,GAAG,CAAC,CAAC,CAC1D"}

package/layers/RuntimeCacheLive.js

@@ -0,0 +1,79 @@
+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 };
+//# sourceMappingURL=RuntimeCacheLive.js.map

package/layers/RuntimeCacheLive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuntimeCacheLive.js","names":["SemVerVersionCache"],"sources":["../../../../src/layers/RuntimeCacheLive.ts"],"sourcesContent":["import { Effect } from \"effect\";\nimport type { SemVer } from \"semver-effect\";\nimport { Range, VersionCache as SemVerVersionCache } from \"semver-effect\";\nimport type { RuntimeRelease } from \"../schemas/runtime-release.js\";\nimport type { RuntimeCache } from \"../services/RuntimeCache.js\";\n\n/**\n * Factory that creates a {@link RuntimeCache} implementation backed by\n * `semver-effect`'s `VersionCache`.\n *\n * The returned `Effect` must be executed within an Effect context that provides\n * a `SemVerVersionCache` service (i.e., it requires `SemVerVersionCache` in its\n * environment). The cache maintains an internal lookup map from version string\n * to the full release object so that resolved semver versions can be\n * round-tripped back to their typed release records.\n *\n * This factory is used internally by {@link BunReleaseCacheLive},\n * {@link DenoReleaseCacheLive}, and {@link NodeReleaseCacheLive} to build their\n * respective cache service implementations. Prefer those higher-level layers\n * over calling this factory directly.\n *\n * Note: `load` is not concurrency-safe. Callers must not invoke it concurrently.\n * In practice this constraint is upheld because `load` is only called from layer\n * setup and `NodeReleaseCacheLive.loadFromInputs`, both of which are serialized\n * by the Effect runtime.\n *\n * @typeParam R - The runtime release type stored in the cache. Must extend\n *   {@link RuntimeRelease}.\n *\n * @see {@link RuntimeCache}\n * @see {@link BunReleaseCacheLive}\n * @see {@link DenoReleaseCacheLive}\n * @see {@link NodeReleaseCacheLive}\n * @public\n */\nexport const createRuntimeCache = <R extends RuntimeRelease>(): Effect.Effect<\n\tRuntimeCache<R>,\n\tnever,\n\tSemVerVersionCache\n> =>\n\tEffect.gen(function* () {\n\t\tconst innerCache = yield* SemVerVersionCache;\n\t\tconst lookupMap = new Map<string, R>();\n\n\t\treturn {\n\t\t\t// NOTE: `load` is not concurrency-safe; callers must not invoke it\n\t\t\t// concurrently. In practice this is only called from layer setup and\n\t\t\t// NodeReleaseCacheLive.loadFromInputs, which are serialized by Effect.\n\t\t\tload: (releases: ReadonlyArray<R>) =>\n\t\t\t\tEffect.gen(function* () {\n\t\t\t\t\tlookupMap.clear();\n\t\t\t\t\tconst versions: SemVer[] = [];\n\t\t\t\t\tfor (const r of releases) {\n\t\t\t\t\t\tconst key = r.version.toString();\n\t\t\t\t\t\tlookupMap.set(key, r);\n\t\t\t\t\t\tversions.push(r.version);\n\t\t\t\t\t}\n\t\t\t\t\tyield* innerCache.load(versions);\n\t\t\t\t}),\n\n\t\t\tresolve: (range: string) =>\n\t\t\t\tEffect.gen(function* () {\n\t\t\t\t\tconst parsed = yield* Range.parse(range);\n\t\t\t\t\tconst resolved = yield* innerCache.resolve(parsed);\n\t\t\t\t\tconst release = lookupMap.get(resolved.toString());\n\t\t\t\t\tif (!release) {\n\t\t\t\t\t\treturn yield* Effect.die(new Error(`Cache inconsistency: ${resolved.toString()} not in lookup map`));\n\t\t\t\t\t}\n\t\t\t\t\treturn release;\n\t\t\t\t}),\n\n\t\t\treleases: () =>\n\t\t\t\tEffect.gen(function* () {\n\t\t\t\t\tconst versions = yield* innerCache.versions.pipe(\n\t\t\t\t\t\tEffect.catchTag(\"EmptyCacheError\", () => Effect.succeed([] as ReadonlyArray<SemVer>)),\n\t\t\t\t\t);\n\t\t\t\t\treturn versions.map((v) => lookupMap.get(v.toString())).filter((r): r is R => r !== undefined);\n\t\t\t\t}),\n\n\t\t\tfilter: (range: string) =>\n\t\t\t\tEffect.gen(function* () {\n\t\t\t\t\tconst parsed = yield* Range.parse(range);\n\t\t\t\t\tconst filtered = yield* innerCache\n\t\t\t\t\t\t.filter(parsed)\n\t\t\t\t\t\t.pipe(Effect.catchTag(\"EmptyCacheError\", () => Effect.succeed([] as ReadonlyArray<SemVer>)));\n\t\t\t\t\treturn filtered.map((v) => lookupMap.get(v.toString())).filter((r): r is R => r !== undefined);\n\t\t\t\t}),\n\n\t\t\tlatest: () =>\n\t\t\t\tEffect.gen(function* () {\n\t\t\t\t\tconst version = yield* innerCache.latest();\n\t\t\t\t\tconst release = lookupMap.get(version.toString());\n\t\t\t\t\tif (!release) {\n\t\t\t\t\t\treturn yield* Effect.die(new Error(`Cache inconsistency: ${version.toString()} not in lookup map`));\n\t\t\t\t\t}\n\t\t\t\t\treturn release;\n\t\t\t\t}),\n\n\t\t\tlatestByMajor: () =>\n\t\t\t\tEffect.gen(function* () {\n\t\t\t\t\tconst versions = yield* innerCache\n\t\t\t\t\t\t.latestByMajor()\n\t\t\t\t\t\t.pipe(Effect.catchTag(\"EmptyCacheError\", () => Effect.succeed([] as ReadonlyArray<SemVer>)));\n\t\t\t\t\treturn versions.map((v) => lookupMap.get(v.toString())).filter((r): r is R => r !== undefined);\n\t\t\t\t}),\n\n\t\t\tlatestByMinor: () =>\n\t\t\t\tEffect.gen(function* () {\n\t\t\t\t\tconst versions = yield* innerCache\n\t\t\t\t\t\t.latestByMinor()\n\t\t\t\t\t\t.pipe(Effect.catchTag(\"EmptyCacheError\", () => Effect.succeed([] as ReadonlyArray<SemVer>)));\n\t\t\t\t\treturn versions.map((v) => lookupMap.get(v.toString())).filter((r): r is R => r !== undefined);\n\t\t\t\t}),\n\t\t};\n\t});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,MAAa,2BAKZ,OAAO,IAAI,aAAa;CACvB,MAAM,aAAa,OAAOA;CAC1B,MAAM,4BAAY,IAAI,IAAe;CAErC,OAAO;EAIN,OAAO,aACN,OAAO,IAAI,aAAa;GACvB,UAAU,MAAM;GAChB,MAAM,WAAqB,CAAC;GAC5B,KAAK,MAAM,KAAK,UAAU;IACzB,MAAM,MAAM,EAAE,QAAQ,SAAS;IAC/B,UAAU,IAAI,KAAK,CAAC;IACpB,SAAS,KAAK,EAAE,OAAO;GACxB;GACA,OAAO,WAAW,KAAK,QAAQ;EAChC,CAAC;EAEF,UAAU,UACT,OAAO,IAAI,aAAa;GACvB,MAAM,SAAS,OAAO,MAAM,MAAM,KAAK;GACvC,MAAM,WAAW,OAAO,WAAW,QAAQ,MAAM;GACjD,MAAM,UAAU,UAAU,IAAI,SAAS,SAAS,CAAC;GACjD,IAAI,CAAC,SACJ,OAAO,OAAO,OAAO,oBAAI,IAAI,MAAM,wBAAwB,SAAS,SAAS,EAAE,mBAAmB,CAAC;GAEpG,OAAO;EACR,CAAC;EAEF,gBACC,OAAO,IAAI,aAAa;GAIvB,QAAO,OAHiB,WAAW,SAAS,KAC3C,OAAO,SAAS,yBAAyB,OAAO,QAAQ,CAAC,CAA0B,CAAC,CACrF,EACe,CAAC,KAAK,MAAM,UAAU,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,QAAQ,MAAc,MAAM,MAAS;EAC9F,CAAC;EAEF,SAAS,UACR,OAAO,IAAI,aAAa;GACvB,MAAM,SAAS,OAAO,MAAM,MAAM,KAAK;GAIvC,QAAO,OAHiB,WACtB,OAAO,MAAM,CAAC,CACd,KAAK,OAAO,SAAS,yBAAyB,OAAO,QAAQ,CAAC,CAA0B,CAAC,CAAC,EAC7E,CAAC,KAAK,MAAM,UAAU,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,QAAQ,MAAc,MAAM,MAAS;EAC9F,CAAC;EAEF,cACC,OAAO,IAAI,aAAa;GACvB,MAAM,UAAU,OAAO,WAAW,OAAO;GACzC,MAAM,UAAU,UAAU,IAAI,QAAQ,SAAS,CAAC;GAChD,IAAI,CAAC,SACJ,OAAO,OAAO,OAAO,oBAAI,IAAI,MAAM,wBAAwB,QAAQ,SAAS,EAAE,mBAAmB,CAAC;GAEnG,OAAO;EACR,CAAC;EAEF,qBACC,OAAO,IAAI,aAAa;GAIvB,QAAO,OAHiB,WACtB,cAAc,CAAC,CACf,KAAK,OAAO,SAAS,yBAAyB,OAAO,QAAQ,CAAC,CAA0B,CAAC,CAAC,EAC7E,CAAC,KAAK,MAAM,UAAU,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,QAAQ,MAAc,MAAM,MAAS;EAC9F,CAAC;EAEF,qBACC,OAAO,IAAI,aAAa;GAIvB,QAAO,OAHiB,WACtB,cAAc,CAAC,CACf,KAAK,OAAO,SAAS,yBAAyB,OAAO,QAAQ,CAAC,CAA0B,CAAC,CAAC,EAC7E,CAAC,KAAK,MAAM,UAAU,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,QAAQ,MAAc,MAAM,MAAS;EAC9F,CAAC;CACH;AACD,CAAC"}

package/lib/retry.js

@@ -0,0 +1,28 @@
+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 };
+//# sourceMappingURL=retry.js.map

package/lib/retry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.js","names":[],"sources":["../../../../src/lib/retry.ts"],"sourcesContent":["import { Effect, Predicate, Schedule } from \"effect\";\n\n/**\n * Wraps an effect with automatic retry logic for {@link RateLimitError}.\n *\n * When the wrapped effect fails with a `RateLimitError` the retry schedule\n * applies exponential backoff starting at a 1-second base delay, doubling on\n * each attempt, for a maximum of 3 retries. Errors with any other tag are\n * re-raised immediately without retrying.\n *\n * The predicate used for the `while` condition is\n * `Predicate.isTagged(\"RateLimitError\")`, so only errors whose `_tag` field\n * equals `\"RateLimitError\"` trigger a retry; all other error types propagate\n * unchanged.\n *\n * @see {@link RateLimitError}\n *\n * @internal\n */\nexport const retryOnRateLimit = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>\n\teffect.pipe(\n\t\tEffect.retry({\n\t\t\tschedule: Schedule.exponential(\"1 second\").pipe(Schedule.compose(Schedule.recurs(3))),\n\t\t\twhile: Predicate.isTagged(\"RateLimitError\"),\n\t\t}),\n\t);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAmBA,MAAa,oBAA6B,WACzC,OAAO,KACN,OAAO,MAAM;CACZ,UAAU,SAAS,YAAY,UAAU,CAAC,CAAC,KAAK,SAAS,QAAQ,SAAS,OAAO,CAAC,CAAC,CAAC;CACpF,OAAO,UAAU,SAAS,gBAAgB;AAC3C,CAAC,CACF"}

package/lib/semver.js

@@ -0,0 +1,22 @@
+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 };
+//# sourceMappingURL=semver.js.map

package/lib/semver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"semver.js","names":[],"sources":["../../../../src/lib/semver.ts"],"sourcesContent":["import { Effect, Option } from \"effect\";\nimport { SemVer } from \"semver-effect\";\n\n/**\n * Attempts to parse a raw version string into a {@link SemVer}, returning\n * `Option.none()` when the string is not a valid semver value.\n *\n * Unlike `SemVer.parse` — which fails the effect on an unparseable input —\n * this helper absorbs parse failures and promotes them into the `Option` channel\n * so that callers can handle invalid versions without short-circuiting the\n * surrounding effect pipeline.\n *\n * @see {@link SemVer.parse}\n *\n * @internal\n */\nexport const tryParseSemVer = (raw: string): Effect.Effect<Option.Option<SemVer>> =>\n\tSemVer.parse(raw).pipe(\n\t\tEffect.map(Option.some),\n\t\tEffect.catchAll(() => Effect.succeed(Option.none())),\n\t);\n"],"mappings":";;;;;;;;;;;;;;;;;AAgBA,MAAa,kBAAkB,QAC9B,OAAO,MAAM,GAAG,CAAC,CAAC,KACjB,OAAO,IAAI,OAAO,IAAI,GACtB,OAAO,eAAe,OAAO,QAAQ,OAAO,KAAK,CAAC,CAAC,CACpD"}

package/package.json

@@ -1,70 +1,59 @@
 {
-  "name": "runtime-resolver",
-  "version": "0.3.12",
-  "private": false,
-  "description": "Resolve semver-compatible versions of Node.js, Bun, and Deno runtimes with Effect-based architecture and offline fallback.",
-  "keywords": [
-    "node",
-    "bun",
-    "deno",
-    "runtime",
-    "version",
-    "semver",
-    "resolver",
-    "ci",
-    "github-actions",
-    "effect",
-    "cli"
-  ],
-  "homepage": "https://github.com/spencerbeggs/runtime-resolver#readme",
-  "bugs": {
-    "url": "https://github.com/spencerbeggs/runtime-resolver/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/spencerbeggs/runtime-resolver.git"
-  },
-  "license": "MIT",
-  "author": {
-    "name": "C. Spencer Beggs",
-    "email": "spencer@beggs.codes",
-    "url": "https://spencerbeg.gs"
-  },
-  "sideEffects": false,
-  "type": "module",
-  "exports": {
-    ".": {
-      "types": "./index.d.ts",
-      "import": "./index.js"
-    }
-  },
-  "bin": {
-    "runtime-resolver": "bin/runtime-resolver.js"
-  },
-  "dependencies": {
-    "@octokit/auth-app": "^8.2.0",
-    "octokit": "^5.0.5",
-    "semver-effect": "^0.2.1"
-  },
-  "peerDependencies": {
-    "@effect/cli": ">=0.75.1",
-    "@effect/platform": ">=0.96.0",
-    "@effect/platform-node": ">=0.106.0",
-    "effect": ">=3.21.0"
-  },
-  "files": [
-    "!runtime-resolver.api.json",
-    "!tsconfig.json",
-    "!tsdoc.json",
-    "612.js",
-    "711.js",
-    "LICENSE",
-    "README.md",
-    "bin/runtime-resolver.js",
-    "index.d.ts",
-    "index.js",
-    "json-schema.js",
-    "package.json",
-    "tsdoc-metadata.json"
-  ]
+	"name": "runtime-resolver",
+	"version": "0.3.13",
+	"private": false,
+	"description": "Resolve semver-compatible versions of Node.js, Bun, and Deno runtimes with Effect-based architecture and offline fallback.",
+	"keywords": [
+		"node",
+		"bun",
+		"deno",
+		"runtime",
+		"version",
+		"semver",
+		"resolver",
+		"ci",
+		"github-actions",
+		"effect",
+		"cli"
+	],
+	"homepage": "https://github.com/spencerbeggs/runtime-resolver#readme",
+	"bugs": {
+		"url": "https://github.com/spencerbeggs/runtime-resolver/issues"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/spencerbeggs/runtime-resolver.git"
+	},
+	"license": "MIT",
+	"author": {
+		"name": "C. Spencer Beggs",
+		"email": "spencer@beggs.codes",
+		"url": "https://spencerbeg.gs"
+	},
+	"sideEffects": false,
+	"type": "module",
+	"exports": {
+		".": {
+			"types": "./index.d.ts",
+			"import": "./index.js"
+		},
+		"./package.json": "./package.json"
+	},
+	"bin": {
+		"runtime-resolver": "bin/runtime-resolver.js"
+	},
+	"dependencies": {
+		"@octokit/auth-app": "^8.2.0",
+		"octokit": "^5.0.5",
+		"semver-effect": "^0.2.1"
+	},
+	"peerDependencies": {
+		"@effect/cli": "catalog:silkPeers",
+		"@effect/platform": "catalog:silkPeers",
+		"@effect/platform-node": "catalog:silkPeers",
+		"effect": "catalog:silkPeers"
+	},
+	"engines": {
+		"node": ">=24.11.0"
+	}
 }

package/schemas/bun-release.js

@@ -0,0 +1,62 @@
+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 };
+//# sourceMappingURL=bun-release.js.map

package/schemas/bun-release.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bun-release.js","names":[],"sources":["../../../../src/schemas/bun-release.ts"],"sourcesContent":["import { Data, DateTime, Effect } from \"effect\";\nimport type { InvalidVersionError } from \"semver-effect\";\nimport { SemVer } from \"semver-effect\";\nimport type { RuntimeReleaseInput } from \"./runtime-release.js\";\n\n/**\n * A Bun release entry with a parsed {@link SemVer} version and an\n * Effect {@link DateTime.DateTime} publication date.\n *\n * `BunRelease` extends `Data.TaggedClass` so instances support structural\n * equality comparison and can be used safely inside Effect data structures.\n * Construct instances via the {@link BunRelease.fromInput} factory rather than\n * calling `new BunRelease(...)` directly, as the factory validates the version\n * string through `SemVer.parse`.\n *\n * @see {@link BunReleaseCache}\n * @see {@link BunResolver}\n * @see {@link RuntimeReleaseInput}\n *\n * @example\n * ```typescript\n * import { Effect } from \"effect\";\n * import type { BunRelease } from \"./bun-release.js\";\n * import { BunRelease as BunReleaseClass } from \"./bun-release.js\";\n *\n * const program = BunReleaseClass.fromInput({ version: \"1.1.0\", date: \"2024-03-01\" }).pipe(\n *   Effect.map((release: BunRelease) => {\n *     console.log(release.version.major); // 1\n *     console.log(release.version.minor); // 1\n *     console.log(release._tag);          // \"BunRelease\"\n *   }),\n * );\n *\n * Effect.runPromise(program);\n * ```\n *\n * @public\n */\nexport class BunRelease extends Data.TaggedClass(\"BunRelease\")<{\n\treadonly version: SemVer;\n\treadonly date: DateTime.DateTime;\n}> {\n\t/**\n\t * Create a {@link BunRelease} from lean string inputs.\n\t *\n\t * Parses `input.version` via `SemVer.parse` and constructs the\n\t * publication date with `DateTime.unsafeMake`. Falls back to the current\n\t * timestamp when `input.date` is an empty string (rare in production data).\n\t *\n\t * @param input - A {@link RuntimeReleaseInput} object with raw string fields.\n\t * @returns An `Effect` that succeeds with a `BunRelease` or fails with an\n\t *   `InvalidVersionError` when the version string cannot be parsed.\n\t */\n\tstatic fromInput(input: RuntimeReleaseInput): Effect.Effect<BunRelease, InvalidVersionError> {\n\t\treturn Effect.gen(function* () {\n\t\t\tconst version = yield* SemVer.parse(input.version);\n\t\t\t// Fall back to current time if published_at is null (rare).\n\t\t\tconst date = input.date ? DateTime.unsafeMake(input.date) : DateTime.unsafeMake(new Date());\n\t\t\treturn new BunRelease({ version, date });\n\t\t});\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,IAAa,aAAb,MAAa,mBAAmB,KAAK,YAAY,YAAY,CAAC,CAG3D;;;;;;;;;;;;CAYF,OAAO,UAAU,OAA4E;EAC5F,OAAO,OAAO,IAAI,aAAa;GAI9B,OAAO,IAAI,WAAW;IAAE,gBAHD,OAAO,MAAM,MAAM,OAAO;IAGhB,MADpB,MAAM,OAAO,SAAS,WAAW,MAAM,IAAI,IAAI,SAAS,2BAAW,IAAI,KAAK,CAAC;GACpD,CAAC;EACxC,CAAC;CACF;AACD"}

package/schemas/deno-release.js

@@ -0,0 +1,62 @@
+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 };
+//# sourceMappingURL=deno-release.js.map

package/schemas/deno-release.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deno-release.js","names":[],"sources":["../../../../src/schemas/deno-release.ts"],"sourcesContent":["import { Data, DateTime, Effect } from \"effect\";\nimport type { InvalidVersionError } from \"semver-effect\";\nimport { SemVer } from \"semver-effect\";\nimport type { RuntimeReleaseInput } from \"./runtime-release.js\";\n\n/**\n * A Deno release entry with a parsed {@link SemVer} version and an\n * Effect {@link DateTime.DateTime} publication date.\n *\n * `DenoRelease` extends `Data.TaggedClass` so instances support structural\n * equality comparison and can be used safely inside Effect data structures.\n * Construct instances via the {@link DenoRelease.fromInput} factory rather than\n * calling `new DenoRelease(...)` directly, as the factory validates the version\n * string through `SemVer.parse`.\n *\n * @see {@link DenoReleaseCache}\n * @see {@link DenoResolver}\n * @see {@link RuntimeReleaseInput}\n *\n * @example\n * ```typescript\n * import { Effect } from \"effect\";\n * import type { DenoRelease } from \"./deno-release.js\";\n * import { DenoRelease as DenoReleaseClass } from \"./deno-release.js\";\n *\n * const program = DenoReleaseClass.fromInput({ version: \"1.44.0\", date: \"2024-05-23\" }).pipe(\n *   Effect.map((release: DenoRelease) => {\n *     console.log(release.version.major); // 1\n *     console.log(release.version.minor); // 44\n *     console.log(release._tag);          // \"DenoRelease\"\n *   }),\n * );\n *\n * Effect.runPromise(program);\n * ```\n *\n * @public\n */\nexport class DenoRelease extends Data.TaggedClass(\"DenoRelease\")<{\n\treadonly version: SemVer;\n\treadonly date: DateTime.DateTime;\n}> {\n\t/**\n\t * Create a {@link DenoRelease} from lean string inputs.\n\t *\n\t * Parses `input.version` via `SemVer.parse` and constructs the\n\t * publication date with `DateTime.unsafeMake`. Falls back to the current\n\t * timestamp when `input.date` is an empty string (rare in production data).\n\t *\n\t * @param input - A {@link RuntimeReleaseInput} object with raw string fields.\n\t * @returns An `Effect` that succeeds with a `DenoRelease` or fails with an\n\t *   `InvalidVersionError` when the version string cannot be parsed.\n\t */\n\tstatic fromInput(input: RuntimeReleaseInput): Effect.Effect<DenoRelease, InvalidVersionError> {\n\t\treturn Effect.gen(function* () {\n\t\t\tconst version = yield* SemVer.parse(input.version);\n\t\t\t// Fall back to current time if published_at is null (rare).\n\t\t\tconst date = input.date ? DateTime.unsafeMake(input.date) : DateTime.unsafeMake(new Date());\n\t\t\treturn new DenoRelease({ version, date });\n\t\t});\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,IAAa,cAAb,MAAa,oBAAoB,KAAK,YAAY,aAAa,CAAC,CAG7D;;;;;;;;;;;;CAYF,OAAO,UAAU,OAA6E;EAC7F,OAAO,OAAO,IAAI,aAAa;GAI9B,OAAO,IAAI,YAAY;IAAE,gBAHF,OAAO,MAAM,MAAM,OAAO;IAGf,MADrB,MAAM,OAAO,SAAS,WAAW,MAAM,IAAI,IAAI,SAAS,2BAAW,IAAI,KAAK,CAAC;GACnD,CAAC;EACzC,CAAC;CACF;AACD"}