runtime-resolver 0.3.11 → 0.3.13

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/schemas/common.ts","../../../src/errors/VersionNotFoundError.ts","../../../src/services/BunResolver.ts","../../../src/services/DenoResolver.ts","../../../src/services/NodeResolver.ts","../../../src/errors/AuthenticationError.ts","../../../src/errors/CacheError.ts","../../../src/errors/FreshnessError.ts","../../../src/errors/InvalidInputError.ts","../../../src/errors/NetworkError.ts","../../../src/errors/ParseError.ts","../../../src/errors/RateLimitError.ts","../../../src/schemas/runtime-release.ts","../../../src/schemas/bun-release.ts","../../../src/services/RuntimeCache.ts","../../../src/services/BunReleaseCache.ts","../../../src/services/BunVersionFetcher.ts","../../../src/layers/AutoBunCacheLive.ts","../../../src/schemas/deno-release.ts","../../../src/services/DenoReleaseCache.ts","../../../src/services/DenoVersionFetcher.ts","../../../src/layers/AutoDenoCacheLive.ts","../../../src/schemas/node-schedule.ts","../../../src/schemas/node-release.ts","../../../src/services/NodeReleaseCache.ts","../../../src/services/NodeScheduleFetcher.ts","../../../src/services/NodeVersionFetcher.ts","../../../src/layers/AutoNodeCacheLive.ts","../../../src/layers/BunReleaseCacheLive.ts","../../../src/layers/BunResolverLive.ts","../../../src/schemas/github.ts","../../../src/services/GitHubClient.ts","../../../src/layers/BunVersionFetcherLive.ts","../../../src/layers/DenoReleaseCacheLive.ts","../../../src/layers/DenoResolverLive.ts","../../../src/layers/DenoVersionFetcherLive.ts","../../../src/layers/FreshBunCacheLive.ts","../../../src/layers/FreshDenoCacheLive.ts","../../../src/layers/FreshNodeCacheLive.ts","../../../src/services/OctokitInstance.ts","../../../src/layers/GitHubAppAuth.ts","../../../src/layers/GitHubAutoAuth.ts","../../../src/layers/GitHubClientLive.ts","../../../src/layers/GitHubTokenAuth.ts","../../../src/layers/NodeReleaseCacheLive.ts","../../../src/layers/NodeResolverLive.ts","../../../src/layers/NodeScheduleFetcherLive.ts","../../../src/layers/NodeVersionFetcherLive.ts","../../../src/layers/OfflineBunCacheLive.ts","../../../src/layers/OfflineDenoCacheLive.ts","../../../src/layers/OfflineNodeCacheLive.ts","../../../src/layers/RuntimeCacheLive.ts","../../../src/index.ts"],"mappings":"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"}

package/index.js

@@ -1,121 +1,63 @@
-import { Data, Effect, Layer } from "effect";
-import { SemVerParserLive, VersionCacheLive } from "semver-effect";
-import { DenoReleaseCacheLive, BunRelease, AutoDenoCacheLive, NodeReleaseCacheLive, NodeReleaseCache, AutoNodeCacheLive, denoDefaultInputs, BunReleaseCache, nodeDefaultInputs, NodeResolverLive, BunVersionFetcherLive, DenoResolverLive, GitHubClientLive, BunVersionFetcher, NodeScheduleFetcher, DenoResolver, NodeScheduleFetcherLive, DenoVersionFetcherLive, NodeVersionFetcher, DenoReleaseCache, BunReleaseCacheLive, BunResolver, DenoRelease, bunDefaultInputs, NodeVersionFetcherLive, GitHubAutoAuth, BunResolverLive, NodeResolver, AutoBunCacheLive, DenoVersionFetcher, nodeDefaultScheduleData } from "./711.js";
-class CacheError extends Data.TaggedError("CacheError") {
-}
-class FreshnessError extends Data.TaggedError("FreshnessError") {
-}
-class InvalidInputError extends Data.TaggedError("InvalidInputError") {
-}
-const freshSetup = Effect.gen(function*() {
-    const cache = yield* BunReleaseCache;
-    const fetcher = yield* BunVersionFetcher;
-    const { inputs } = yield* fetcher.fetch().pipe(Effect.catchTags({
-        AuthenticationError: (err)=>Effect.fail(new FreshnessError({
-                strategy: "api",
-                message: `Fresh data required but authentication failed: ${err.message}`
-            })),
-        NetworkError: (err)=>Effect.fail(new FreshnessError({
-                strategy: "api",
-                message: `Fresh data required but network unavailable: ${err.message}`
-            })),
-        ParseError: (err)=>Effect.fail(new FreshnessError({
-                strategy: "api",
-                message: `Fresh data required but parse failed: ${err.message}`
-            })),
-        RateLimitError: (err)=>Effect.fail(new FreshnessError({
-                strategy: "api",
-                message: `Fresh data required but rate limit exceeded: ${err.message}`
-            }))
-    }));
-    const releases = yield* Effect.all(inputs.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));
-const FreshBunCacheLive = BaseCacheLayer.pipe(Layer.tap((ctx)=>freshSetup.pipe(Effect.provide(ctx))));
-const FreshDenoCacheLive_freshSetup = Effect.gen(function*() {
-    const cache = yield* DenoReleaseCache;
-    const fetcher = yield* DenoVersionFetcher;
-    const { inputs } = yield* fetcher.fetch().pipe(Effect.catchTags({
-        AuthenticationError: (err)=>Effect.fail(new FreshnessError({
-                strategy: "api",
-                message: `Fresh data required but authentication failed: ${err.message}`
-            })),
-        NetworkError: (err)=>Effect.fail(new FreshnessError({
-                strategy: "api",
-                message: `Fresh data required but network unavailable: ${err.message}`
-            })),
-        ParseError: (err)=>Effect.fail(new FreshnessError({
-                strategy: "api",
-                message: `Fresh data required but parse failed: ${err.message}`
-            })),
-        RateLimitError: (err)=>Effect.fail(new FreshnessError({
-                strategy: "api",
-                message: `Fresh data required but rate limit exceeded: ${err.message}`
-            }))
-    }));
-    const releases = yield* Effect.all(inputs.map((input)=>DenoRelease.fromInput(input)), {
-        concurrency: "unbounded"
-    }).pipe(Effect.orElseSucceed(()=>[]));
-    yield* cache.load(releases);
-});
-const FreshDenoCacheLive_SemVerLayer = VersionCacheLive.pipe(Layer.provide(SemVerParserLive));
-const FreshDenoCacheLive_BaseCacheLayer = DenoReleaseCacheLive.pipe(Layer.provide(FreshDenoCacheLive_SemVerLayer));
-const FreshDenoCacheLive = FreshDenoCacheLive_BaseCacheLayer.pipe(Layer.tap((ctx)=>FreshDenoCacheLive_freshSetup.pipe(Effect.provide(ctx))));
-const FreshNodeCacheLive_freshSetup = Effect.gen(function*() {
-    const cache = yield* NodeReleaseCache;
-    const versionFetcher = yield* NodeVersionFetcher;
-    const scheduleFetcher = yield* NodeScheduleFetcher;
-    const [fetchResult, scheduleData] = yield* Effect.all([
-        versionFetcher.fetch(),
-        scheduleFetcher.fetch()
-    ]).pipe(Effect.catchTags({
-        NetworkError: (err)=>Effect.fail(new FreshnessError({
-                strategy: "api",
-                message: `Fresh data required but network unavailable: ${err.message}`
-            })),
-        ParseError: (err)=>Effect.fail(new FreshnessError({
-                strategy: "api",
-                message: `Fresh data required but response could not be parsed: ${err.message}`
-            }))
-    }));
-    yield* cache.updateSchedule(scheduleData);
-    yield* cache.loadFromInputs(fetchResult.inputs);
-});
-const FreshNodeCacheLive_SemVerLayer = VersionCacheLive.pipe(Layer.provide(SemVerParserLive));
-const FreshNodeCacheLive_BaseCacheLayer = NodeReleaseCacheLive.pipe(Layer.provide(FreshNodeCacheLive_SemVerLayer));
-const FreshNodeCacheLive = FreshNodeCacheLive_BaseCacheLayer.pipe(Layer.tap((ctx)=>FreshNodeCacheLive_freshSetup.pipe(Effect.provide(ctx))));
-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 OfflineBunCacheLive_SemVerLayer = VersionCacheLive.pipe(Layer.provide(SemVerParserLive));
-const OfflineBunCacheLive_BaseCacheLayer = BunReleaseCacheLive.pipe(Layer.provide(OfflineBunCacheLive_SemVerLayer));
-const OfflineBunCacheLive = OfflineBunCacheLive_BaseCacheLayer.pipe(Layer.tap((ctx)=>offlineSetup.pipe(Effect.provide(ctx))));
-const OfflineDenoCacheLive_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 OfflineDenoCacheLive_SemVerLayer = VersionCacheLive.pipe(Layer.provide(SemVerParserLive));
-const OfflineDenoCacheLive_BaseCacheLayer = DenoReleaseCacheLive.pipe(Layer.provide(OfflineDenoCacheLive_SemVerLayer));
-const OfflineDenoCacheLive = OfflineDenoCacheLive_BaseCacheLayer.pipe(Layer.tap((ctx)=>OfflineDenoCacheLive_offlineSetup.pipe(Effect.provide(ctx))));
-const OfflineNodeCacheLive_offlineSetup = Effect.gen(function*() {
-    const cache = yield* NodeReleaseCache;
-    yield* cache.updateSchedule(nodeDefaultScheduleData);
-    yield* cache.loadFromInputs(nodeDefaultInputs);
-});
-const OfflineNodeCacheLive_SemVerLayer = VersionCacheLive.pipe(Layer.provide(SemVerParserLive));
-const OfflineNodeCacheLive_BaseCacheLayer = NodeReleaseCacheLive.pipe(Layer.provide(OfflineNodeCacheLive_SemVerLayer));
-const OfflineNodeCacheLive = OfflineNodeCacheLive_BaseCacheLayer.pipe(Layer.tap((ctx)=>OfflineNodeCacheLive_offlineSetup.pipe(Effect.provide(ctx))));
+import { BunRelease } from "./schemas/bun-release.js";
+import { BunReleaseCache } from "./services/BunReleaseCache.js";
+import { BunVersionFetcher } from "./services/BunVersionFetcher.js";
+import { createRuntimeCache } from "./layers/RuntimeCacheLive.js";
+import { BunReleaseCacheLive } from "./layers/BunReleaseCacheLive.js";
+import { AutoBunCacheLive } from "./layers/AutoBunCacheLive.js";
+import { DenoRelease } from "./schemas/deno-release.js";
+import { DenoReleaseCache } from "./services/DenoReleaseCache.js";
+import { DenoVersionFetcher } from "./services/DenoVersionFetcher.js";
+import { DenoReleaseCacheLive } from "./layers/DenoReleaseCacheLive.js";
+import { AutoDenoCacheLive } from "./layers/AutoDenoCacheLive.js";
+import { NodeReleaseCache } from "./services/NodeReleaseCache.js";
+import { NodeScheduleFetcher } from "./services/NodeScheduleFetcher.js";
+import { NodeVersionFetcher } from "./services/NodeVersionFetcher.js";
+import { NodeRelease } from "./schemas/node-release.js";
+import { NodeSchedule } from "./schemas/node-schedule.js";
+import { NodeReleaseCacheLive } from "./layers/NodeReleaseCacheLive.js";
+import { AutoNodeCacheLive } from "./layers/AutoNodeCacheLive.js";
+import { VersionNotFoundError } from "./errors/VersionNotFoundError.js";
+import { BunResolver } from "./services/BunResolver.js";
+import { BunResolverLive } from "./layers/BunResolverLive.js";
+import { GitHubClient } from "./services/GitHubClient.js";
+import { BunVersionFetcherLive } from "./layers/BunVersionFetcherLive.js";
+import { DenoResolver } from "./services/DenoResolver.js";
+import { DenoResolverLive } from "./layers/DenoResolverLive.js";
+import { DenoVersionFetcherLive } from "./layers/DenoVersionFetcherLive.js";
+import { OctokitInstance } from "./services/OctokitInstance.js";
+import { AuthenticationError } from "./errors/AuthenticationError.js";
+import { GitHubAppAuth } from "./layers/GitHubAppAuth.js";
+import { GitHubAutoAuth } from "./layers/GitHubAutoAuth.js";
+import { NetworkError } from "./errors/NetworkError.js";
+import { ParseError } from "./errors/ParseError.js";
+import { RateLimitError } from "./errors/RateLimitError.js";
+import { GitHubClientLive } from "./layers/GitHubClientLive.js";
+import { NodeResolver } from "./services/NodeResolver.js";
+import { NodeResolverLive } from "./layers/NodeResolverLive.js";
+import { NodeScheduleFetcherLive } from "./layers/NodeScheduleFetcherLive.js";
+import { NodeVersionFetcherLive } from "./layers/NodeVersionFetcherLive.js";
+import { CacheError } from "./errors/CacheError.js";
+import { FreshnessError } from "./errors/FreshnessError.js";
+import { InvalidInputError } from "./errors/InvalidInputError.js";
+import { FreshBunCacheLive } from "./layers/FreshBunCacheLive.js";
+import { FreshDenoCacheLive } from "./layers/FreshDenoCacheLive.js";
+import { FreshNodeCacheLive } from "./layers/FreshNodeCacheLive.js";
+import { GitHubTokenAuth, GitHubTokenAuthFromToken } from "./layers/GitHubTokenAuth.js";
+import { OfflineBunCacheLive } from "./layers/OfflineBunCacheLive.js";
+import { OfflineDenoCacheLive } from "./layers/OfflineDenoCacheLive.js";
+import { OfflineNodeCacheLive } from "./layers/OfflineNodeCacheLive.js";
+import { Effect, Layer } from "effect";
+
+//#region src/index.ts
+/**
+* runtime-resolver
+*
+* Resolve semver-compatible versions of Node.js, Bun, and Deno runtimes.
+* Promise-based API with offline fallback via build-time cache.
+* Also exports Effect services, layers, and errors for advanced composition.
+*
+* @packageDocumentation
+*/
 const GitHubLayer = GitHubClientLive.pipe(Layer.provide(GitHubAutoAuth));
 const NodeFetchersLayer = Layer.merge(NodeVersionFetcherLive.pipe(Layer.provide(GitHubLayer)), NodeScheduleFetcherLive.pipe(Layer.provide(GitHubLayer)));
 const NodeCacheLayer = AutoNodeCacheLive.pipe(Layer.provide(NodeFetchersLayer));
@@ -124,17 +66,102 @@ const BunCacheLayer = AutoBunCacheLive.pipe(Layer.provide(BunVersionFetcherLive.
 const BunLayer = BunResolverLive.pipe(Layer.provide(BunCacheLayer));
 const DenoCacheLayer = AutoDenoCacheLive.pipe(Layer.provide(DenoVersionFetcherLive.pipe(Layer.provide(GitHubLayer))));
 const DenoLayer = DenoResolverLive.pipe(Layer.provide(DenoCacheLayer));
-const resolveNode = (options)=>Effect.runPromise(Effect.gen(function*() {
-        const resolver = yield* NodeResolver;
-        return yield* resolver.resolve(options);
-    }).pipe(Effect.provide(NodeLayer)));
-const resolveBun = (options)=>Effect.runPromise(Effect.gen(function*() {
-        const resolver = yield* BunResolver;
-        return yield* resolver.resolve(options);
-    }).pipe(Effect.provide(BunLayer)));
-const resolveDeno = (options)=>Effect.runPromise(Effect.gen(function*() {
-        const resolver = yield* DenoResolver;
-        return yield* resolver.resolve(options);
-    }).pipe(Effect.provide(DenoLayer)));
-export { AuthenticationError, AutoBunCacheLive, AutoDenoCacheLive, AutoNodeCacheLive, BunRelease, BunReleaseCache, BunReleaseCacheLive, BunResolver, BunResolverLive, BunVersionFetcher, BunVersionFetcherLive, DenoRelease, DenoReleaseCache, DenoReleaseCacheLive, DenoResolver, DenoResolverLive, DenoVersionFetcher, DenoVersionFetcherLive, GitHubAppAuth, GitHubAutoAuth, GitHubClient, GitHubClientLive, GitHubTokenAuth, GitHubTokenAuthFromToken, NetworkError, NodeRelease, NodeReleaseCache, NodeReleaseCacheLive, NodeResolver, NodeResolverLive, NodeSchedule, NodeScheduleFetcher, NodeScheduleFetcherLive, NodeVersionFetcher, NodeVersionFetcherLive, OctokitInstance, ParseError, RateLimitError, VersionNotFoundError, createRuntimeCache } from "./711.js";
-export { CacheError, FreshBunCacheLive, FreshDenoCacheLive, FreshNodeCacheLive, FreshnessError, InvalidInputError, OfflineBunCacheLive, OfflineDenoCacheLive, OfflineNodeCacheLive, resolveBun, resolveDeno, resolveNode };
+/**
+* Resolve Node.js versions matching the given options.
+*
+* Fetches release data from the Node.js GitHub repository and the official
+* release schedule API, then filters and ranks versions according to
+* `options`. Authentication is read from `GITHUB_PERSONAL_ACCESS_TOKEN` or
+* `GITHUB_TOKEN` environment variables. Falls back to a build-time offline
+* cache when the network is unavailable.
+*
+* @param options - Filtering and ranking options. See {@link NodeResolverOptions}.
+* @returns A promise that resolves to a {@link ResolvedVersions} object
+*   containing the matched version list, the highest matching version as
+*   `latest`, and optional `lts` / `default` strings.
+*
+* @example
+* ```ts
+* import type { ResolvedVersions } from "runtime-resolver";
+* import { resolveNode } from "runtime-resolver";
+*
+* const result: ResolvedVersions = await resolveNode({
+* 	semverRange: ">=20.0.0",
+* 	phases: ["active-lts"],
+* });
+* console.log(result.latest); // e.g. "22.11.0"
+* console.log(result.versions); // all matching versions
+* ```
+*
+* @see {@link NodeResolver} for the Effect-based API
+* @see {@link NodeResolverOptions} for available options
+*
+* @public
+*/
+const resolveNode = (options) => Effect.runPromise(Effect.gen(function* () {
+	return yield* (yield* NodeResolver).resolve(options);
+}).pipe(Effect.provide(NodeLayer)));
+/**
+* Resolve Bun versions matching the given options.
+*
+* Fetches release data from the Bun GitHub repository, then filters and ranks
+* versions according to `options`. Authentication is read from
+* `GITHUB_PERSONAL_ACCESS_TOKEN` or `GITHUB_TOKEN` environment variables.
+* Falls back to a build-time offline cache when the network is unavailable.
+*
+* @param options - Filtering and ranking options. See {@link BunResolverOptions}.
+* @returns A promise that resolves to a {@link ResolvedVersions} object
+*   containing the matched version list and the highest matching version as
+*   `latest`.
+*
+* @example
+* ```ts
+* import type { ResolvedVersions } from "runtime-resolver";
+* import { resolveBun } from "runtime-resolver";
+*
+* const result: ResolvedVersions = await resolveBun({ semverRange: "^1.0.0" });
+* console.log(result.latest);
+* ```
+*
+* @see {@link BunResolver} for the Effect-based API
+* @see {@link BunResolverOptions} for available options
+*
+* @public
+*/
+const resolveBun = (options) => Effect.runPromise(Effect.gen(function* () {
+	return yield* (yield* BunResolver).resolve(options);
+}).pipe(Effect.provide(BunLayer)));
+/**
+* Resolve Deno versions matching the given options.
+*
+* Fetches release data from the Deno GitHub repository, then filters and ranks
+* versions according to `options`. Authentication is read from
+* `GITHUB_PERSONAL_ACCESS_TOKEN` or `GITHUB_TOKEN` environment variables.
+* Falls back to a build-time offline cache when the network is unavailable.
+*
+* @param options - Filtering and ranking options. See {@link DenoResolverOptions}.
+* @returns A promise that resolves to a {@link ResolvedVersions} object
+*   containing the matched version list and the highest matching version as
+*   `latest`.
+*
+* @example
+* ```ts
+* import type { ResolvedVersions } from "runtime-resolver";
+* import { resolveDeno } from "runtime-resolver";
+*
+* const result: ResolvedVersions = await resolveDeno({ semverRange: "^2.0.0" });
+* console.log(result.latest);
+* ```
+*
+* @see {@link DenoResolver} for the Effect-based API
+* @see {@link DenoResolverOptions} for available options
+*
+* @public
+*/
+const resolveDeno = (options) => Effect.runPromise(Effect.gen(function* () {
+	return yield* (yield* DenoResolver).resolve(options);
+}).pipe(Effect.provide(DenoLayer)));
+
+//#endregion
+export { AuthenticationError, AutoBunCacheLive, AutoDenoCacheLive, AutoNodeCacheLive, BunRelease, BunReleaseCache, BunReleaseCacheLive, BunResolver, BunResolverLive, BunVersionFetcher, BunVersionFetcherLive, CacheError, DenoRelease, DenoReleaseCache, DenoReleaseCacheLive, DenoResolver, DenoResolverLive, DenoVersionFetcher, DenoVersionFetcherLive, FreshBunCacheLive, FreshDenoCacheLive, FreshNodeCacheLive, FreshnessError, GitHubAppAuth, GitHubAutoAuth, GitHubClient, GitHubClientLive, GitHubTokenAuth, GitHubTokenAuthFromToken, InvalidInputError, NetworkError, NodeRelease, NodeReleaseCache, NodeReleaseCacheLive, NodeResolver, NodeResolverLive, NodeSchedule, NodeScheduleFetcher, NodeScheduleFetcherLive, NodeVersionFetcher, NodeVersionFetcherLive, OctokitInstance, OfflineBunCacheLive, OfflineDenoCacheLive, OfflineNodeCacheLive, ParseError, RateLimitError, VersionNotFoundError, createRuntimeCache, resolveBun, resolveDeno, resolveNode };
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/index.ts"],"sourcesContent":["/**\n * runtime-resolver\n *\n * Resolve semver-compatible versions of Node.js, Bun, and Deno runtimes.\n * Promise-based API with offline fallback via build-time cache.\n * Also exports Effect services, layers, and errors for advanced composition.\n *\n * @packageDocumentation\n */\nimport { Effect, Layer } from \"effect\";\nimport { AutoBunCacheLive } from \"./layers/AutoBunCacheLive.js\";\nimport { AutoDenoCacheLive } from \"./layers/AutoDenoCacheLive.js\";\nimport { AutoNodeCacheLive } from \"./layers/AutoNodeCacheLive.js\";\nimport { BunResolverLive } from \"./layers/BunResolverLive.js\";\nimport { BunVersionFetcherLive } from \"./layers/BunVersionFetcherLive.js\";\nimport { DenoResolverLive } from \"./layers/DenoResolverLive.js\";\nimport { DenoVersionFetcherLive } from \"./layers/DenoVersionFetcherLive.js\";\nimport { GitHubAutoAuth } from \"./layers/GitHubAutoAuth.js\";\nimport { GitHubClientLive } from \"./layers/GitHubClientLive.js\";\nimport { NodeResolverLive } from \"./layers/NodeResolverLive.js\";\nimport { NodeScheduleFetcherLive } from \"./layers/NodeScheduleFetcherLive.js\";\nimport { NodeVersionFetcherLive } from \"./layers/NodeVersionFetcherLive.js\";\nimport type { ResolvedVersions } from \"./schemas/common.js\";\nimport type { BunResolverOptions } from \"./services/BunResolver.js\";\nimport { BunResolver } from \"./services/BunResolver.js\";\nimport type { DenoResolverOptions } from \"./services/DenoResolver.js\";\nimport { DenoResolver } from \"./services/DenoResolver.js\";\nimport type { NodeResolverOptions } from \"./services/NodeResolver.js\";\nimport { NodeResolver } from \"./services/NodeResolver.js\";\n\nconst GitHubLayer = GitHubClientLive.pipe(Layer.provide(GitHubAutoAuth));\nconst NodeFetchersLayer = Layer.merge(\n\tNodeVersionFetcherLive.pipe(Layer.provide(GitHubLayer)),\n\tNodeScheduleFetcherLive.pipe(Layer.provide(GitHubLayer)),\n);\nconst NodeCacheLayer = AutoNodeCacheLive.pipe(Layer.provide(NodeFetchersLayer));\nconst NodeLayer = NodeResolverLive.pipe(Layer.provide(NodeCacheLayer));\n\nconst BunCacheLayer = AutoBunCacheLive.pipe(Layer.provide(BunVersionFetcherLive.pipe(Layer.provide(GitHubLayer))));\nconst BunLayer = BunResolverLive.pipe(Layer.provide(BunCacheLayer));\n\nconst DenoCacheLayer = AutoDenoCacheLive.pipe(Layer.provide(DenoVersionFetcherLive.pipe(Layer.provide(GitHubLayer))));\nconst DenoLayer = DenoResolverLive.pipe(Layer.provide(DenoCacheLayer));\n\n// ── Errors ──────────────────────────────────────────────────────────────────\n// Tagged error classes thrown by the Promise API and surfaced through Effect\n// channels.\nexport { AuthenticationError } from \"./errors/AuthenticationError.js\";\nexport { CacheError } from \"./errors/CacheError.js\";\nexport { FreshnessError } from \"./errors/FreshnessError.js\";\nexport { InvalidInputError } from \"./errors/InvalidInputError.js\";\nexport { NetworkError } from \"./errors/NetworkError.js\";\nexport { ParseError } from \"./errors/ParseError.js\";\nexport { RateLimitError } from \"./errors/RateLimitError.js\";\nexport { VersionNotFoundError } from \"./errors/VersionNotFoundError.js\";\n\n// ── Layers ──────────────────────────────────────────────────────────────────\n// Effect `Layer` implementations that wire up every runtime resolver's full\n// dependency graph. Use these when composing custom Effect pipelines instead\n// of relying on the Promise API.\nexport { AutoBunCacheLive } from \"./layers/AutoBunCacheLive.js\";\nexport { AutoDenoCacheLive } from \"./layers/AutoDenoCacheLive.js\";\nexport { AutoNodeCacheLive } from \"./layers/AutoNodeCacheLive.js\";\nexport { BunReleaseCacheLive } from \"./layers/BunReleaseCacheLive.js\";\nexport { BunResolverLive } from \"./layers/BunResolverLive.js\";\nexport { BunVersionFetcherLive } from \"./layers/BunVersionFetcherLive.js\";\nexport { DenoReleaseCacheLive } from \"./layers/DenoReleaseCacheLive.js\";\nexport { DenoResolverLive } from \"./layers/DenoResolverLive.js\";\nexport { DenoVersionFetcherLive } from \"./layers/DenoVersionFetcherLive.js\";\nexport { FreshBunCacheLive } from \"./layers/FreshBunCacheLive.js\";\nexport { FreshDenoCacheLive } from \"./layers/FreshDenoCacheLive.js\";\nexport { FreshNodeCacheLive } from \"./layers/FreshNodeCacheLive.js\";\nexport type { GitHubAppAuthConfig } from \"./layers/GitHubAppAuth.js\";\nexport { GitHubAppAuth } from \"./layers/GitHubAppAuth.js\";\nexport { GitHubAutoAuth } from \"./layers/GitHubAutoAuth.js\";\nexport { GitHubClientLive } from \"./layers/GitHubClientLive.js\";\nexport { GitHubTokenAuth, GitHubTokenAuthFromToken } from \"./layers/GitHubTokenAuth.js\";\nexport { NodeReleaseCacheLive } from \"./layers/NodeReleaseCacheLive.js\";\nexport { NodeResolverLive } from \"./layers/NodeResolverLive.js\";\nexport { NodeScheduleFetcherLive } from \"./layers/NodeScheduleFetcherLive.js\";\nexport { NodeVersionFetcherLive } from \"./layers/NodeVersionFetcherLive.js\";\nexport { OfflineBunCacheLive } from \"./layers/OfflineBunCacheLive.js\";\nexport { OfflineDenoCacheLive } from \"./layers/OfflineDenoCacheLive.js\";\nexport { OfflineNodeCacheLive } from \"./layers/OfflineNodeCacheLive.js\";\nexport { createRuntimeCache } from \"./layers/RuntimeCacheLive.js\";\n// ── Schemas ──────────────────────────────────────────────────────────────────\n// Effect `Schema` codecs for runtime release data.\nexport { BunRelease } from \"./schemas/bun-release.js\";\n// ── Types ───────────────────────────────────────────────────────────────────\n// TypeScript type aliases and branded primitives shared across all runtimes.\nexport type { Increments, NodePhase, ResolvedVersions, Runtime, Source } from \"./schemas/common.js\";\nexport { DenoRelease } from \"./schemas/deno-release.js\";\nexport type { GitHubRelease, GitHubTag } from \"./schemas/github.js\";\nexport type { NodeReleaseInput } from \"./schemas/node-release.js\";\nexport { NodeRelease } from \"./schemas/node-release.js\";\nexport type { NodeScheduleData, NodeScheduleEntry } from \"./schemas/node-schedule.js\";\nexport { NodeSchedule } from \"./schemas/node-schedule.js\";\nexport type { RuntimeRelease, RuntimeReleaseInput } from \"./schemas/runtime-release.js\";\n// ── Services ────────────────────────────────────────────────────────────────\n// Effect `Context.Tag` service interfaces and their option/error types.\n// Inject these into your own Effect programs for fine-grained control over\n// caching, fetching, and resolution behaviour.\nexport { BunReleaseCache } from \"./services/BunReleaseCache.js\";\nexport type { BunResolverError, BunResolverOptions } from \"./services/BunResolver.js\";\nexport { BunResolver } from \"./services/BunResolver.js\";\nexport { BunVersionFetcher } from \"./services/BunVersionFetcher.js\";\nexport { DenoReleaseCache } from \"./services/DenoReleaseCache.js\";\nexport type { DenoResolverError, DenoResolverOptions } from \"./services/DenoResolver.js\";\nexport { DenoResolver } from \"./services/DenoResolver.js\";\nexport { DenoVersionFetcher } from \"./services/DenoVersionFetcher.js\";\nexport type { ListOptions } from \"./services/GitHubClient.js\";\nexport { GitHubClient } from \"./services/GitHubClient.js\";\nexport { NodeReleaseCache } from \"./services/NodeReleaseCache.js\";\nexport type { NodeResolverError, NodeResolverOptions } from \"./services/NodeResolver.js\";\nexport { NodeResolver } from \"./services/NodeResolver.js\";\nexport { NodeScheduleFetcher } from \"./services/NodeScheduleFetcher.js\";\nexport { NodeVersionFetcher } from \"./services/NodeVersionFetcher.js\";\nexport { OctokitInstance } from \"./services/OctokitInstance.js\";\nexport type { RuntimeCache } from \"./services/RuntimeCache.js\";\n\n// ── Promise API ─────────────────────────────────────────────────────────────\n\n/**\n * Resolve Node.js versions matching the given options.\n *\n * Fetches release data from the Node.js GitHub repository and the official\n * release schedule API, then filters and ranks versions according to\n * `options`. Authentication is read from `GITHUB_PERSONAL_ACCESS_TOKEN` or\n * `GITHUB_TOKEN` environment variables. Falls back to a build-time offline\n * cache when the network is unavailable.\n *\n * @param options - Filtering and ranking options. See {@link NodeResolverOptions}.\n * @returns A promise that resolves to a {@link ResolvedVersions} object\n *   containing the matched version list, the highest matching version as\n *   `latest`, and optional `lts` / `default` strings.\n *\n * @example\n * ```ts\n * import type { ResolvedVersions } from \"runtime-resolver\";\n * import { resolveNode } from \"runtime-resolver\";\n *\n * const result: ResolvedVersions = await resolveNode({\n * \tsemverRange: \">=20.0.0\",\n * \tphases: [\"active-lts\"],\n * });\n * console.log(result.latest); // e.g. \"22.11.0\"\n * console.log(result.versions); // all matching versions\n * ```\n *\n * @see {@link NodeResolver} for the Effect-based API\n * @see {@link NodeResolverOptions} for available options\n *\n * @public\n */\nexport const resolveNode = (options?: NodeResolverOptions): Promise<ResolvedVersions> =>\n\tEffect.runPromise(\n\t\tEffect.gen(function* () {\n\t\t\tconst resolver = yield* NodeResolver;\n\t\t\treturn yield* resolver.resolve(options);\n\t\t}).pipe(Effect.provide(NodeLayer)),\n\t);\n\n/**\n * Resolve Bun versions matching the given options.\n *\n * Fetches release data from the Bun GitHub repository, then filters and ranks\n * versions according to `options`. Authentication is read from\n * `GITHUB_PERSONAL_ACCESS_TOKEN` or `GITHUB_TOKEN` environment variables.\n * Falls back to a build-time offline cache when the network is unavailable.\n *\n * @param options - Filtering and ranking options. See {@link BunResolverOptions}.\n * @returns A promise that resolves to a {@link ResolvedVersions} object\n *   containing the matched version list and the highest matching version as\n *   `latest`.\n *\n * @example\n * ```ts\n * import type { ResolvedVersions } from \"runtime-resolver\";\n * import { resolveBun } from \"runtime-resolver\";\n *\n * const result: ResolvedVersions = await resolveBun({ semverRange: \"^1.0.0\" });\n * console.log(result.latest);\n * ```\n *\n * @see {@link BunResolver} for the Effect-based API\n * @see {@link BunResolverOptions} for available options\n *\n * @public\n */\nexport const resolveBun = (options?: BunResolverOptions): Promise<ResolvedVersions> =>\n\tEffect.runPromise(\n\t\tEffect.gen(function* () {\n\t\t\tconst resolver = yield* BunResolver;\n\t\t\treturn yield* resolver.resolve(options);\n\t\t}).pipe(Effect.provide(BunLayer)),\n\t);\n\n/**\n * Resolve Deno versions matching the given options.\n *\n * Fetches release data from the Deno GitHub repository, then filters and ranks\n * versions according to `options`. Authentication is read from\n * `GITHUB_PERSONAL_ACCESS_TOKEN` or `GITHUB_TOKEN` environment variables.\n * Falls back to a build-time offline cache when the network is unavailable.\n *\n * @param options - Filtering and ranking options. See {@link DenoResolverOptions}.\n * @returns A promise that resolves to a {@link ResolvedVersions} object\n *   containing the matched version list and the highest matching version as\n *   `latest`.\n *\n * @example\n * ```ts\n * import type { ResolvedVersions } from \"runtime-resolver\";\n * import { resolveDeno } from \"runtime-resolver\";\n *\n * const result: ResolvedVersions = await resolveDeno({ semverRange: \"^2.0.0\" });\n * console.log(result.latest);\n * ```\n *\n * @see {@link DenoResolver} for the Effect-based API\n * @see {@link DenoResolverOptions} for available options\n *\n * @public\n */\nexport const resolveDeno = (options?: DenoResolverOptions): Promise<ResolvedVersions> =>\n\tEffect.runPromise(\n\t\tEffect.gen(function* () {\n\t\t\tconst resolver = yield* DenoResolver;\n\t\t\treturn yield* resolver.resolve(options);\n\t\t}).pipe(Effect.provide(DenoLayer)),\n\t);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,MAAM,cAAc,iBAAiB,KAAK,MAAM,QAAQ,cAAc,CAAC;AACvE,MAAM,oBAAoB,MAAM,MAC/B,uBAAuB,KAAK,MAAM,QAAQ,WAAW,CAAC,GACtD,wBAAwB,KAAK,MAAM,QAAQ,WAAW,CAAC,CACxD;AACA,MAAM,iBAAiB,kBAAkB,KAAK,MAAM,QAAQ,iBAAiB,CAAC;AAC9E,MAAM,YAAY,iBAAiB,KAAK,MAAM,QAAQ,cAAc,CAAC;AAErE,MAAM,gBAAgB,iBAAiB,KAAK,MAAM,QAAQ,sBAAsB,KAAK,MAAM,QAAQ,WAAW,CAAC,CAAC,CAAC;AACjH,MAAM,WAAW,gBAAgB,KAAK,MAAM,QAAQ,aAAa,CAAC;AAElE,MAAM,iBAAiB,kBAAkB,KAAK,MAAM,QAAQ,uBAAuB,KAAK,MAAM,QAAQ,WAAW,CAAC,CAAC,CAAC;AACpH,MAAM,YAAY,iBAAiB,KAAK,MAAM,QAAQ,cAAc,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgHrE,MAAa,eAAe,YAC3B,OAAO,WACN,OAAO,IAAI,aAAa;CAEvB,OAAO,QAAO,OADU,aACF,CAAC,QAAQ,OAAO;AACvC,CAAC,CAAC,CAAC,KAAK,OAAO,QAAQ,SAAS,CAAC,CAClC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BD,MAAa,cAAc,YAC1B,OAAO,WACN,OAAO,IAAI,aAAa;CAEvB,OAAO,QAAO,OADU,YACF,CAAC,QAAQ,OAAO;AACvC,CAAC,CAAC,CAAC,KAAK,OAAO,QAAQ,QAAQ,CAAC,CACjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BD,MAAa,eAAe,YAC3B,OAAO,WACN,OAAO,IAAI,aAAa;CAEvB,OAAO,QAAO,OADU,aACF,CAAC,QAAQ,OAAO;AACvC,CAAC,CAAC,CAAC,KAAK,OAAO,QAAQ,SAAS,CAAC,CAClC"}

package/layers/AutoBunCacheLive.js

@@ -0,0 +1,48 @@
+import { bunDefaultInputs } from "../data/bun-defaults.js";
+import { BunRelease } from "../schemas/bun-release.js";
+import { BunReleaseCache } from "../services/BunReleaseCache.js";
+import { BunVersionFetcher } from "../services/BunVersionFetcher.js";
+import { BunReleaseCacheLive } from "./BunReleaseCacheLive.js";
+import { Effect, Layer } from "effect";
+import { SemVerParserLive, VersionCacheLive } from "semver-effect";
+
+//#region src/layers/AutoBunCacheLive.ts
+const setup = Effect.gen(function* () {
+	const cache = yield* BunReleaseCache;
+	const inputs = yield* (yield* BunVersionFetcher).fetch().pipe(Effect.map((result) => result.inputs), Effect.catchTags({
+		AuthenticationError: () => Effect.succeed(bunDefaultInputs),
+		NetworkError: () => Effect.succeed(bunDefaultInputs),
+		ParseError: () => Effect.succeed(bunDefaultInputs),
+		RateLimitError: () => Effect.succeed(bunDefaultInputs)
+	}));
+	const releases = yield* Effect.all(inputs.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 "Auto" cache strategy.
+*
+* Attempts to fetch live release data from the GitHub API via
+* {@link BunVersionFetcher}. If the fetch fails for any reason — authentication
+* errors, network errors, parse errors, or rate-limit errors — it silently falls
+* back to the bundled default release data so the layer always succeeds.
+*
+* Use this strategy when you want the freshest data when available but can
+* tolerate slightly stale bundled data in degraded environments.
+*
+* The three Bun cache strategy layers are:
+* - `AutoBunCacheLive` — tries API first, falls back to bundled defaults on any error
+* - {@link FreshBunCacheLive} — requires live API data, fails with `FreshnessError` if unavailable
+* - {@link OfflineBunCacheLive} — uses only bundled defaults, no network I/O
+*
+* @see {@link BunReleaseCache}
+* @see {@link FreshBunCacheLive}
+* @see {@link OfflineBunCacheLive}
+* @public
+*/
+const AutoBunCacheLive = BaseCacheLayer.pipe(Layer.tap((ctx) => setup.pipe(Effect.provide(ctx))));
+
+//#endregion
+export { AutoBunCacheLive };
+//# sourceMappingURL=AutoBunCacheLive.js.map

package/layers/AutoBunCacheLive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AutoBunCacheLive.js","names":["SemVerVersionCacheLive"],"sources":["../../../../src/layers/AutoBunCacheLive.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 { BunVersionFetcher } from \"../services/BunVersionFetcher.js\";\nimport { BunReleaseCacheLive } from \"./BunReleaseCacheLive.js\";\n\nconst setup = Effect.gen(function* () {\n\tconst cache = yield* BunReleaseCache;\n\tconst fetcher = yield* BunVersionFetcher;\n\n\tconst inputs = yield* fetcher.fetch().pipe(\n\t\tEffect.map((result) => result.inputs),\n\t\tEffect.catchTags({\n\t\t\tAuthenticationError: () => Effect.succeed(bunDefaultInputs),\n\t\t\tNetworkError: () => Effect.succeed(bunDefaultInputs),\n\t\t\tParseError: () => Effect.succeed(bunDefaultInputs),\n\t\t\tRateLimitError: () => Effect.succeed(bunDefaultInputs),\n\t\t}),\n\t);\n\n\tconst releases = yield* Effect.all(\n\t\tinputs.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 \"Auto\" cache strategy.\n *\n * Attempts to fetch live release data from the GitHub API via\n * {@link BunVersionFetcher}. If the fetch fails for any reason — authentication\n * errors, network errors, parse errors, or rate-limit errors — it silently falls\n * back to the bundled default release data so the layer always succeeds.\n *\n * Use this strategy when you want the freshest data when available but can\n * tolerate slightly stale bundled data in degraded environments.\n *\n * The three Bun cache strategy layers are:\n * - `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 * - {@link OfflineBunCacheLive} — uses only bundled defaults, no network I/O\n *\n * @see {@link BunReleaseCache}\n * @see {@link FreshBunCacheLive}\n * @see {@link OfflineBunCacheLive}\n * @public\n */\nexport const AutoBunCacheLive: Layer.Layer<BunReleaseCache, never, BunVersionFetcher> = BaseCacheLayer.pipe(\n\tLayer.tap((ctx) => setup.pipe(Effect.provide(ctx))),\n);\n"],"mappings":";;;;;;;;;AAQA,MAAM,QAAQ,OAAO,IAAI,aAAa;CACrC,MAAM,QAAQ,OAAO;CAGrB,MAAM,SAAS,QAAO,OAFC,kBAEM,CAAC,MAAM,CAAC,CAAC,KACrC,OAAO,KAAK,WAAW,OAAO,MAAM,GACpC,OAAO,UAAU;EAChB,2BAA2B,OAAO,QAAQ,gBAAgB;EAC1D,oBAAoB,OAAO,QAAQ,gBAAgB;EACnD,kBAAkB,OAAO,QAAQ,gBAAgB;EACjD,sBAAsB,OAAO,QAAQ,gBAAgB;CACtD,CAAC,CACF;CAEA,MAAM,WAAW,OAAO,OAAO,IAC9B,OAAO,KAAK,UAAU,WAAW,UAAU,KAAK,CAAC,GACjD,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,mBAA2E,eAAe,KACtG,MAAM,KAAK,QAAQ,MAAM,KAAK,OAAO,QAAQ,GAAG,CAAC,CAAC,CACnD"}

package/layers/AutoDenoCacheLive.js

@@ -0,0 +1,48 @@
+import { denoDefaultInputs } from "../data/deno-defaults.js";
+import { DenoRelease } from "../schemas/deno-release.js";
+import { DenoReleaseCache } from "../services/DenoReleaseCache.js";
+import { DenoVersionFetcher } from "../services/DenoVersionFetcher.js";
+import { DenoReleaseCacheLive } from "./DenoReleaseCacheLive.js";
+import { Effect, Layer } from "effect";
+import { SemVerParserLive, VersionCacheLive } from "semver-effect";
+
+//#region src/layers/AutoDenoCacheLive.ts
+const setup = Effect.gen(function* () {
+	const cache = yield* DenoReleaseCache;
+	const inputs = yield* (yield* DenoVersionFetcher).fetch().pipe(Effect.map((result) => result.inputs), Effect.catchTags({
+		AuthenticationError: () => Effect.succeed(denoDefaultInputs),
+		NetworkError: () => Effect.succeed(denoDefaultInputs),
+		ParseError: () => Effect.succeed(denoDefaultInputs),
+		RateLimitError: () => Effect.succeed(denoDefaultInputs)
+	}));
+	const releases = yield* Effect.all(inputs.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 "Auto" cache strategy.
+*
+* Attempts to fetch live release data from the GitHub API via
+* {@link DenoVersionFetcher}. If the fetch fails for any reason — authentication
+* errors, network errors, parse errors, or rate-limit errors — it silently falls
+* back to the bundled default release data so the layer always succeeds.
+*
+* Use this strategy when you want the freshest data when available but can
+* tolerate slightly stale bundled data in degraded environments.
+*
+* The three Deno cache strategy layers are:
+* - `AutoDenoCacheLive` — tries API first, falls back to bundled defaults on any error
+* - {@link FreshDenoCacheLive} — requires live API data, fails with `FreshnessError` if unavailable
+* - {@link OfflineDenoCacheLive} — uses only bundled defaults, no network I/O
+*
+* @see {@link DenoReleaseCache}
+* @see {@link FreshDenoCacheLive}
+* @see {@link OfflineDenoCacheLive}
+* @public
+*/
+const AutoDenoCacheLive = BaseCacheLayer.pipe(Layer.tap((ctx) => setup.pipe(Effect.provide(ctx))));
+
+//#endregion
+export { AutoDenoCacheLive };
+//# sourceMappingURL=AutoDenoCacheLive.js.map

package/layers/AutoDenoCacheLive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AutoDenoCacheLive.js","names":["SemVerVersionCacheLive"],"sources":["../../../../src/layers/AutoDenoCacheLive.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 { DenoVersionFetcher } from \"../services/DenoVersionFetcher.js\";\nimport { DenoReleaseCacheLive } from \"./DenoReleaseCacheLive.js\";\n\nconst setup = Effect.gen(function* () {\n\tconst cache = yield* DenoReleaseCache;\n\tconst fetcher = yield* DenoVersionFetcher;\n\n\tconst inputs = yield* fetcher.fetch().pipe(\n\t\tEffect.map((result) => result.inputs),\n\t\tEffect.catchTags({\n\t\t\tAuthenticationError: () => Effect.succeed(denoDefaultInputs),\n\t\t\tNetworkError: () => Effect.succeed(denoDefaultInputs),\n\t\t\tParseError: () => Effect.succeed(denoDefaultInputs),\n\t\t\tRateLimitError: () => Effect.succeed(denoDefaultInputs),\n\t\t}),\n\t);\n\n\tconst releases = yield* Effect.all(\n\t\tinputs.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 \"Auto\" cache strategy.\n *\n * Attempts to fetch live release data from the GitHub API via\n * {@link DenoVersionFetcher}. If the fetch fails for any reason — authentication\n * errors, network errors, parse errors, or rate-limit errors — it silently falls\n * back to the bundled default release data so the layer always succeeds.\n *\n * Use this strategy when you want the freshest data when available but can\n * tolerate slightly stale bundled data in degraded environments.\n *\n * The three Deno cache strategy layers are:\n * - `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 * - {@link OfflineDenoCacheLive} — uses only bundled defaults, no network I/O\n *\n * @see {@link DenoReleaseCache}\n * @see {@link FreshDenoCacheLive}\n * @see {@link OfflineDenoCacheLive}\n * @public\n */\nexport const AutoDenoCacheLive: Layer.Layer<DenoReleaseCache, never, DenoVersionFetcher> = BaseCacheLayer.pipe(\n\tLayer.tap((ctx) => setup.pipe(Effect.provide(ctx))),\n);\n"],"mappings":";;;;;;;;;AAQA,MAAM,QAAQ,OAAO,IAAI,aAAa;CACrC,MAAM,QAAQ,OAAO;CAGrB,MAAM,SAAS,QAAO,OAFC,mBAEM,CAAC,MAAM,CAAC,CAAC,KACrC,OAAO,KAAK,WAAW,OAAO,MAAM,GACpC,OAAO,UAAU;EAChB,2BAA2B,OAAO,QAAQ,iBAAiB;EAC3D,oBAAoB,OAAO,QAAQ,iBAAiB;EACpD,kBAAkB,OAAO,QAAQ,iBAAiB;EAClD,sBAAsB,OAAO,QAAQ,iBAAiB;CACvD,CAAC,CACF;CAEA,MAAM,WAAW,OAAO,OAAO,IAC9B,OAAO,KAAK,UAAU,YAAY,UAAU,KAAK,CAAC,GAClD,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,oBAA8E,eAAe,KACzG,MAAM,KAAK,QAAQ,MAAM,KAAK,OAAO,QAAQ,GAAG,CAAC,CAAC,CACnD"}

package/layers/AutoNodeCacheLive.js

@@ -0,0 +1,59 @@
+import { nodeDefaultInputs, nodeDefaultScheduleData } from "../data/node-defaults.js";
+import { NodeReleaseCache } from "../services/NodeReleaseCache.js";
+import { NodeScheduleFetcher } from "../services/NodeScheduleFetcher.js";
+import { NodeVersionFetcher } from "../services/NodeVersionFetcher.js";
+import { NodeReleaseCacheLive } from "./NodeReleaseCacheLive.js";
+import { Effect, Layer } from "effect";
+import { SemVerParserLive, VersionCacheLive } from "semver-effect";
+
+//#region src/layers/AutoNodeCacheLive.ts
+const setup = Effect.gen(function* () {
+	const cache = yield* NodeReleaseCache;
+	const versionFetcher = yield* NodeVersionFetcher;
+	const scheduleFetcher = yield* NodeScheduleFetcher;
+	const nodeDefaults = {
+		inputs: nodeDefaultInputs,
+		scheduleData: nodeDefaultScheduleData
+	};
+	const { inputs, scheduleData } = yield* Effect.gen(function* () {
+		const [fetchResult, schedule] = yield* Effect.all([versionFetcher.fetch(), scheduleFetcher.fetch()]);
+		return {
+			inputs: fetchResult.inputs,
+			scheduleData: schedule
+		};
+	}).pipe(Effect.catchTags({
+		NetworkError: () => Effect.succeed(nodeDefaults),
+		ParseError: () => Effect.succeed(nodeDefaults)
+	}));
+	yield* cache.updateSchedule(scheduleData);
+	yield* cache.loadFromInputs(inputs);
+});
+const SemVerLayer = VersionCacheLive.pipe(Layer.provide(SemVerParserLive));
+const BaseCacheLayer = NodeReleaseCacheLive.pipe(Layer.provide(SemVerLayer));
+/**
+* Provides the {@link NodeReleaseCache} service using the "Auto" cache strategy.
+*
+* Attempts to fetch live release data from `nodejs.org/dist/index.json` via
+* {@link NodeVersionFetcher} and the release schedule from the `nodejs/Release`
+* repository via {@link NodeScheduleFetcher}. If either fetch fails — due to
+* network errors or parse errors — the layer silently falls back to bundled
+* default data (both version list and schedule) so it always succeeds.
+*
+* Node.js requires both a version fetcher and a schedule fetcher because LTS and
+* maintenance phase information is tracked separately from the version index.
+*
+* The three Node cache strategy layers are:
+* - `AutoNodeCacheLive` — tries API first, falls back to bundled defaults on any error
+* - {@link FreshNodeCacheLive} — requires live API data, fails with `FreshnessError` if unavailable
+* - {@link OfflineNodeCacheLive} — uses only bundled defaults, no network I/O
+*
+* @see {@link NodeReleaseCache}
+* @see {@link FreshNodeCacheLive}
+* @see {@link OfflineNodeCacheLive}
+* @public
+*/
+const AutoNodeCacheLive = BaseCacheLayer.pipe(Layer.tap((ctx) => setup.pipe(Effect.provide(ctx))));
+
+//#endregion
+export { AutoNodeCacheLive };
+//# sourceMappingURL=AutoNodeCacheLive.js.map

package/layers/AutoNodeCacheLive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AutoNodeCacheLive.js","names":["SemVerVersionCacheLive"],"sources":["../../../../src/layers/AutoNodeCacheLive.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 { NodeScheduleFetcher } from \"../services/NodeScheduleFetcher.js\";\nimport { NodeVersionFetcher } from \"../services/NodeVersionFetcher.js\";\nimport { NodeReleaseCacheLive } from \"./NodeReleaseCacheLive.js\";\n\nconst setup = Effect.gen(function* () {\n\tconst cache = yield* NodeReleaseCache;\n\tconst versionFetcher = yield* NodeVersionFetcher;\n\tconst scheduleFetcher = yield* NodeScheduleFetcher;\n\n\tconst nodeDefaults = { inputs: nodeDefaultInputs, scheduleData: nodeDefaultScheduleData };\n\tconst { inputs, scheduleData } = yield* Effect.gen(function* () {\n\t\tconst [fetchResult, schedule] = yield* Effect.all([versionFetcher.fetch(), scheduleFetcher.fetch()]);\n\t\treturn { inputs: fetchResult.inputs, scheduleData: schedule };\n\t}).pipe(\n\t\tEffect.catchTags({\n\t\t\tNetworkError: () => Effect.succeed(nodeDefaults),\n\t\t\tParseError: () => Effect.succeed(nodeDefaults),\n\t\t}),\n\t);\n\n\tyield* cache.updateSchedule(scheduleData);\n\tyield* cache.loadFromInputs(inputs);\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 \"Auto\" cache strategy.\n *\n * Attempts to fetch live release data from `nodejs.org/dist/index.json` via\n * {@link NodeVersionFetcher} and the release schedule from the `nodejs/Release`\n * repository via {@link NodeScheduleFetcher}. If either fetch fails — due to\n * network errors or parse errors — the layer silently falls back to bundled\n * default data (both version list and schedule) so it always succeeds.\n *\n * Node.js requires both a version fetcher and a schedule fetcher because LTS and\n * maintenance phase information is tracked separately from the version index.\n *\n * The three Node cache strategy layers are:\n * - `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 * - {@link OfflineNodeCacheLive} — uses only bundled defaults, no network I/O\n *\n * @see {@link NodeReleaseCache}\n * @see {@link FreshNodeCacheLive}\n * @see {@link OfflineNodeCacheLive}\n * @public\n */\nexport const AutoNodeCacheLive: Layer.Layer<NodeReleaseCache, never, NodeVersionFetcher | NodeScheduleFetcher> =\n\tBaseCacheLayer.pipe(Layer.tap((ctx) => setup.pipe(Effect.provide(ctx))));\n"],"mappings":";;;;;;;;;AAQA,MAAM,QAAQ,OAAO,IAAI,aAAa;CACrC,MAAM,QAAQ,OAAO;CACrB,MAAM,iBAAiB,OAAO;CAC9B,MAAM,kBAAkB,OAAO;CAE/B,MAAM,eAAe;EAAE,QAAQ;EAAmB,cAAc;CAAwB;CACxF,MAAM,EAAE,QAAQ,iBAAiB,OAAO,OAAO,IAAI,aAAa;EAC/D,MAAM,CAAC,aAAa,YAAY,OAAO,OAAO,IAAI,CAAC,eAAe,MAAM,GAAG,gBAAgB,MAAM,CAAC,CAAC;EACnG,OAAO;GAAE,QAAQ,YAAY;GAAQ,cAAc;EAAS;CAC7D,CAAC,CAAC,CAAC,KACF,OAAO,UAAU;EAChB,oBAAoB,OAAO,QAAQ,YAAY;EAC/C,kBAAkB,OAAO,QAAQ,YAAY;CAC9C,CAAC,CACF;CAEA,OAAO,MAAM,eAAe,YAAY;CACxC,OAAO,MAAM,eAAe,MAAM;AACnC,CAAC;AAED,MAAM,cAAcA,iBAAuB,KAAK,MAAM,QAAQ,gBAAgB,CAAC;AAC/E,MAAM,iBAAiB,qBAAqB,KAAK,MAAM,QAAQ,WAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;AAwB3E,MAAa,oBACZ,eAAe,KAAK,MAAM,KAAK,QAAQ,MAAM,KAAK,OAAO,QAAQ,GAAG,CAAC,CAAC,CAAC"}

package/layers/BunReleaseCacheLive.js

@@ -0,0 +1,26 @@
+import { BunReleaseCache } from "../services/BunReleaseCache.js";
+import { createRuntimeCache } from "./RuntimeCacheLive.js";
+import { Layer } from "effect";
+
+//#region src/layers/BunReleaseCacheLive.ts
+/**
+* Low-level layer that constructs the {@link BunReleaseCache} service backed by
+* a `SemVerVersionCache` instance from `semver-effect`.
+*
+* This layer wires up the cache storage but does not populate it with any
+* release data. Callers are responsible for loading releases after construction.
+* In normal usage you should prefer the higher-level cache strategy layers
+* instead of using this layer directly:
+* - {@link AutoBunCacheLive} — API with fallback to bundled defaults
+* - {@link FreshBunCacheLive} — API only, fails if unavailable
+* - {@link OfflineBunCacheLive} — bundled defaults only
+*
+* @see {@link BunReleaseCache}
+* @see {@link createRuntimeCache}
+* @internal
+*/
+const BunReleaseCacheLive = Layer.effect(BunReleaseCache, createRuntimeCache());
+
+//#endregion
+export { BunReleaseCacheLive };
+//# sourceMappingURL=BunReleaseCacheLive.js.map

package/layers/BunReleaseCacheLive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BunReleaseCacheLive.js","names":[],"sources":["../../../../src/layers/BunReleaseCacheLive.ts"],"sourcesContent":["import { Layer } from \"effect\";\nimport type { VersionCache as SemVerVersionCache } from \"semver-effect\";\nimport type { BunRelease } from \"../schemas/bun-release.js\";\nimport { BunReleaseCache } from \"../services/BunReleaseCache.js\";\nimport { createRuntimeCache } from \"./RuntimeCacheLive.js\";\n\n/**\n * Low-level layer that constructs the {@link BunReleaseCache} service backed by\n * a `SemVerVersionCache` instance from `semver-effect`.\n *\n * This layer wires up the cache storage but does not populate it with any\n * release data. Callers are responsible for loading releases after construction.\n * In normal usage you should prefer the higher-level cache strategy layers\n * instead of using this layer directly:\n * - {@link AutoBunCacheLive} — API with fallback to bundled defaults\n * - {@link FreshBunCacheLive} — API only, fails if unavailable\n * - {@link OfflineBunCacheLive} — bundled defaults only\n *\n * @see {@link BunReleaseCache}\n * @see {@link createRuntimeCache}\n * @internal\n */\nexport const BunReleaseCacheLive: Layer.Layer<BunReleaseCache, never, SemVerVersionCache> = Layer.effect(\n\tBunReleaseCache,\n\tcreateRuntimeCache<BunRelease>(),\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,sBAA+E,MAAM,OACjG,iBACA,mBAA+B,CAChC"}