runtime-resolver 0.3.13 → 0.3.14

package/index.d.ts.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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"}

package/layers/BunResolverLive.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"BunResolverLive.js","names":[],"sources":["../../../../src/layers/BunResolverLive.ts"],"sourcesContent":["import { Effect, Layer } from \"effect\";\nimport { SemVer } from \"semver-effect\";\nimport { VersionNotFoundError } from \"../errors/VersionNotFoundError.js\";\nimport type { BunRelease } from \"../schemas/bun-release.js\";\nimport type { Increments } from \"../schemas/common.js\";\nimport { BunReleaseCache } from \"../services/BunReleaseCache.js\";\nimport type { BunResolverOptions } from \"../services/BunResolver.js\";\nimport { BunResolver } from \"../services/BunResolver.js\";\n\n/**\n * Provides the {@link BunResolver} service backed by a {@link BunReleaseCache}.\n *\n * This layer composes with any of the three Bun cache strategy layers to form\n * a complete resolver stack. It implements semver range filtering and increment\n * grouping (latest per major, latest per minor, or all patch versions) using\n * the releases already loaded into the cache.\n *\n * @example\n * ```ts\n * import { BunResolverLive, AutoBunCacheLive, BunVersionFetcherLive, GitHubClientLive, GitHubAutoAuth } from \"runtime-resolver\";\n * import type { ResolvedVersions } from \"runtime-resolver\";\n * import { BunResolver } from \"runtime-resolver\";\n * import { Effect, Layer } from \"effect\";\n *\n * const GitHubLayer = GitHubClientLive.pipe(Layer.provide(GitHubAutoAuth));\n * const CacheLayer = AutoBunCacheLive.pipe(Layer.provide(BunVersionFetcherLive.pipe(Layer.provide(GitHubLayer))));\n * const ResolverLayer = BunResolverLive.pipe(Layer.provide(CacheLayer));\n *\n * const program = Effect.gen(function* () {\n *   const resolver = yield* BunResolver;\n *   const result = yield* resolver.resolve({ semverRange: \"^1.0.0\" });\n *   console.log(result.latest);\n * });\n *\n * Effect.runPromise(program.pipe(Effect.provide(ResolverLayer)));\n * ```\n *\n * @see {@link BunResolver}\n * @see {@link BunReleaseCache}\n * @see {@link AutoBunCacheLive}\n * @see {@link FreshBunCacheLive}\n * @see {@link OfflineBunCacheLive}\n * @public\n */\nexport const BunResolverLive: Layer.Layer<BunResolver, never, BunReleaseCache> = Layer.effect(\n\tBunResolver,\n\tEffect.gen(function* () {\n\t\tconst cache = yield* BunReleaseCache;\n\n\t\treturn {\n\t\t\tresolve: (options?: BunResolverOptions) =>\n\t\t\t\tEffect.gen(function* () {\n\t\t\t\t\tconst semverRange = options?.semverRange ?? \"*\";\n\t\t\t\t\tconst increments: Increments = options?.increments ?? \"latest\";\n\n\t\t\t\t\tconst matching = yield* cache\n\t\t\t\t\t\t.filter(semverRange)\n\t\t\t\t\t\t.pipe(Effect.catchAll(() => Effect.succeed([] as ReadonlyArray<BunRelease>)));\n\n\t\t\t\t\tlet resultReleases: BunRelease[];\n\t\t\t\t\tif (increments === \"latest\") {\n\t\t\t\t\t\tconst groups = new Map<number, BunRelease>();\n\t\t\t\t\t\tfor (const r of matching) {\n\t\t\t\t\t\t\tconst existing = groups.get(r.version.major);\n\t\t\t\t\t\t\tif (!existing || SemVer.gt(r.version, existing.version)) {\n\t\t\t\t\t\t\t\tgroups.set(r.version.major, r);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tresultReleases = [...groups.values()];\n\t\t\t\t\t} else if (increments === \"minor\") {\n\t\t\t\t\t\tconst groups = new Map<string, BunRelease>();\n\t\t\t\t\t\tfor (const r of matching) {\n\t\t\t\t\t\t\tconst key = `${r.version.major}.${r.version.minor}`;\n\t\t\t\t\t\t\tconst existing = groups.get(key);\n\t\t\t\t\t\t\tif (!existing || SemVer.gt(r.version, existing.version)) {\n\t\t\t\t\t\t\t\tgroups.set(key, r);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tresultReleases = [...groups.values()];\n\t\t\t\t\t} else {\n\t\t\t\t\t\tresultReleases = [...matching];\n\t\t\t\t\t}\n\n\t\t\t\t\tif (resultReleases.length === 0) {\n\t\t\t\t\t\treturn yield* Effect.fail(\n\t\t\t\t\t\t\tnew VersionNotFoundError({\n\t\t\t\t\t\t\t\truntime: \"bun\",\n\t\t\t\t\t\t\t\tconstraint: semverRange,\n\t\t\t\t\t\t\t\tmessage: `No Bun versions found matching \"${semverRange}\"`,\n\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\n\t\t\t\t\tconst sorted = SemVer.rsort(resultReleases.map((r) => r.version));\n\t\t\t\t\tconst versions = sorted.map((v) => v.toString());\n\t\t\t\t\tconst latest = versions[0];\n\n\t\t\t\t\tlet resolvedDefault: string | undefined;\n\t\t\t\t\tif (options?.defaultVersion) {\n\t\t\t\t\t\tresolvedDefault = yield* cache.resolve(options.defaultVersion).pipe(\n\t\t\t\t\t\t\tEffect.map((r) => r.version.toString()),\n\t\t\t\t\t\t\tEffect.catchAll(() => Effect.succeed(undefined)),\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\n\t\t\t\t\treturn {\n\t\t\t\t\t\tsource: \"api\" as const,\n\t\t\t\t\t\tversions,\n\t\t\t\t\t\tlatest,\n\t\t\t\t\t\t...(resolvedDefault ? { default: resolvedDefault } : {}),\n\t\t\t\t\t};\n\t\t\t\t}),\n\t\t};\n\t}),\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,MAAa,kBAAoE,MAAM,OACtF,aACA,OAAO,IAAI,aAAa;CACvB,MAAM,QAAQ,OAAO;CAErB,OAAO,EACN,UAAU,YACT,OAAO,IAAI,aAAa;EACvB,MAAM,cAAc,SAAS,eAAe;EAC5C,MAAM,aAAyB,SAAS,cAAc;EAEtD,MAAM,WAAW,OAAO,MACtB,OAAO,WAAW,CAAC,CACnB,KAAK,OAAO,eAAe,OAAO,QAAQ,CAAC,CAA8B,CAAC,CAAC;EAE7E,IAAI;EACJ,IAAI,eAAe,UAAU;GAC5B,MAAM,yBAAS,IAAI,IAAwB;GAC3C,KAAK,MAAM,KAAK,UAAU;IACzB,MAAM,WAAW,OAAO,IAAI,EAAE,QAAQ,KAAK;IAC3C,IAAI,CAAC,YAAY,OAAO,GAAG,EAAE,SAAS,SAAS,OAAO,GACrD,OAAO,IAAI,EAAE,QAAQ,OAAO,CAAC;GAE/B;GACA,iBAAiB,CAAC,GAAG,OAAO,OAAO,CAAC;EACrC,OAAO,IAAI,eAAe,SAAS;GAClC,MAAM,yBAAS,IAAI,IAAwB;GAC3C,KAAK,MAAM,KAAK,UAAU;IACzB,MAAM,MAAM,GAAG,EAAE,QAAQ,MAAM,GAAG,EAAE,QAAQ;IAC5C,MAAM,WAAW,OAAO,IAAI,GAAG;IAC/B,IAAI,CAAC,YAAY,OAAO,GAAG,EAAE,SAAS,SAAS,OAAO,GACrD,OAAO,IAAI,KAAK,CAAC;GAEnB;GACA,iBAAiB,CAAC,GAAG,OAAO,OAAO,CAAC;EACrC,OACC,iBAAiB,CAAC,GAAG,QAAQ;EAG9B,IAAI,eAAe,WAAW,GAC7B,OAAO,OAAO,OAAO,KACpB,IAAI,qBAAqB;GACxB,SAAS;GACT,YAAY;GACZ,SAAS,mCAAmC,YAAY;EACzD,CAAC,CACF;EAID,MAAM,WADS,OAAO,MAAM,eAAe,KAAK,MAAM,EAAE,OAAO,CACzC,CAAC,CAAC,KAAK,MAAM,EAAE,SAAS,CAAC;EAC/C,MAAM,SAAS,SAAS;EAExB,IAAI;EACJ,IAAI,SAAS,gBACZ,kBAAkB,OAAO,MAAM,QAAQ,QAAQ,cAAc,CAAC,CAAC,KAC9D,OAAO,KAAK,MAAM,EAAE,QAAQ,SAAS,CAAC,GACtC,OAAO,eAAe,OAAO,QAAQ,MAAS,CAAC,CAChD;EAGD,OAAO;GACN,QAAQ;GACR;GACA;GACA,GAAI,kBAAkB,EAAE,SAAS,gBAAgB,IAAI,CAAC;EACvD;CACD,CAAC,EACH;AACD,CAAC,CACF"}

package/layers/BunVersionFetcherLive.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"BunVersionFetcherLive.js","names":[],"sources":["../../../../src/layers/BunVersionFetcherLive.ts"],"sourcesContent":["import { Effect, Layer, Option } from \"effect\";\nimport { retryOnRateLimit } from \"../lib/retry.js\";\nimport { tryParseSemVer } from \"../lib/semver.js\";\nimport type { RuntimeReleaseInput } from \"../schemas/runtime-release.js\";\nimport { BunVersionFetcher } from \"../services/BunVersionFetcher.js\";\nimport { GitHubClient } from \"../services/GitHubClient.js\";\n\n/**\n * Strip bun- prefix and v/V prefix, parse to SemVer.\n */\nconst normalizeBunTag = (tagName: string): Effect.Effect<Option.Option<import(\"semver-effect\").SemVer>> => {\n\tconst version = tagName.startsWith(\"bun-\") ? tagName.slice(4) : tagName;\n\tconst stripped = version.startsWith(\"v\") || version.startsWith(\"V\") ? version.slice(1) : version;\n\treturn tryParseSemVer(stripped);\n};\n\n/**\n * Provides the {@link BunVersionFetcher} service using the live GitHub API.\n *\n * Fetches Bun releases from the `oven-sh/bun` GitHub repository using the\n * provided {@link GitHubClient}. Draft releases and pre-releases are excluded.\n * Tag names are normalized by stripping the `bun-` prefix and any leading `v`\n * or `V` before parsing as semver.\n *\n * This layer is a required dependency of {@link AutoBunCacheLive} and\n * {@link FreshBunCacheLive}. It is not needed by {@link OfflineBunCacheLive}.\n *\n * @see {@link BunVersionFetcher}\n * @see {@link GitHubClient}\n * @see {@link AutoBunCacheLive}\n * @see {@link FreshBunCacheLive}\n * @public\n */\nexport const BunVersionFetcherLive: Layer.Layer<BunVersionFetcher, never, GitHubClient> = Layer.effect(\n\tBunVersionFetcher,\n\tEffect.gen(function* () {\n\t\tconst client = yield* GitHubClient;\n\n\t\treturn {\n\t\t\tfetch: () =>\n\t\t\t\tEffect.gen(function* () {\n\t\t\t\t\tconst releases = yield* retryOnRateLimit(client.listReleases(\"oven-sh\", \"bun\", { perPage: 100, pages: 3 }));\n\t\t\t\t\tconst fallbackDate = new Date().toISOString().slice(0, 10);\n\n\t\t\t\t\tconst parsed = yield* Effect.forEach(\n\t\t\t\t\t\treleases.filter((r) => !r.draft && !r.prerelease),\n\t\t\t\t\t\t(release) =>\n\t\t\t\t\t\t\tnormalizeBunTag(release.tag_name).pipe(\n\t\t\t\t\t\t\t\tEffect.map((opt) =>\n\t\t\t\t\t\t\t\t\tOption.isSome(opt)\n\t\t\t\t\t\t\t\t\t\t? Option.some({\n\t\t\t\t\t\t\t\t\t\t\t\tversion: opt.value,\n\t\t\t\t\t\t\t\t\t\t\t\tinput: {\n\t\t\t\t\t\t\t\t\t\t\t\t\tversion: opt.value.toString(),\n\t\t\t\t\t\t\t\t\t\t\t\t\tdate: release.published_at ?? fallbackDate,\n\t\t\t\t\t\t\t\t\t\t\t\t} satisfies RuntimeReleaseInput,\n\t\t\t\t\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t\t\t\t: Option.none(),\n\t\t\t\t\t\t\t\t),\n\t\t\t\t\t\t\t),\n\t\t\t\t\t\t{ concurrency: \"unbounded\" },\n\t\t\t\t\t);\n\n\t\t\t\t\tconst versions = parsed.flatMap(Option.toArray).map(({ version }) => version);\n\t\t\t\t\tconst inputs = parsed.flatMap(Option.toArray).map(({ input }) => input);\n\n\t\t\t\t\treturn { versions, inputs };\n\t\t\t\t}),\n\t\t};\n\t}),\n);\n"],"mappings":";;;;;;;;;;AAUA,MAAM,mBAAmB,YAAkF;CAC1G,MAAM,UAAU,QAAQ,WAAW,MAAM,IAAI,QAAQ,MAAM,CAAC,IAAI;CAEhE,OAAO,eADU,QAAQ,WAAW,GAAG,KAAK,QAAQ,WAAW,GAAG,IAAI,QAAQ,MAAM,CAAC,IAAI,OAC3D;AAC/B;;;;;;;;;;;;;;;;;;AAmBA,MAAa,wBAA6E,MAAM,OAC/F,mBACA,OAAO,IAAI,aAAa;CACvB,MAAM,SAAS,OAAO;CAEtB,OAAO,EACN,aACC,OAAO,IAAI,aAAa;EACvB,MAAM,WAAW,OAAO,iBAAiB,OAAO,aAAa,WAAW,OAAO;GAAE,SAAS;GAAK,OAAO;EAAE,CAAC,CAAC;EAC1G,MAAM,gCAAe,IAAI,KAAK,EAAC,CAAC,YAAY,CAAC,CAAC,MAAM,GAAG,EAAE;EAEzD,MAAM,SAAS,OAAO,OAAO,QAC5B,SAAS,QAAQ,MAAM,CAAC,EAAE,SAAS,CAAC,EAAE,UAAU,IAC/C,YACA,gBAAgB,QAAQ,QAAQ,CAAC,CAAC,KACjC,OAAO,KAAK,QACX,OAAO,OAAO,GAAG,IACd,OAAO,KAAK;GACZ,SAAS,IAAI;GACb,OAAO;IACN,SAAS,IAAI,MAAM,SAAS;IAC5B,MAAM,QAAQ,gBAAgB;GAC/B;EACD,CAAC,IACA,OAAO,KAAK,CAChB,CACD,GACD,EAAE,aAAa,YAAY,CAC5B;EAKA,OAAO;GAAE,UAHQ,OAAO,QAAQ,OAAO,OAAO,CAAC,CAAC,KAAK,EAAE,cAAc,OAGrD;GAAG,QAFJ,OAAO,QAAQ,OAAO,OAAO,CAAC,CAAC,KAAK,EAAE,YAAY,KAEzC;EAAE;CAC3B,CAAC,EACH;AACD,CAAC,CACF"}

package/layers/DenoReleaseCacheLive.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"DenoReleaseCacheLive.js","names":[],"sources":["../../../../src/layers/DenoReleaseCacheLive.ts"],"sourcesContent":["import { Layer } from \"effect\";\nimport type { VersionCache as SemVerVersionCache } from \"semver-effect\";\nimport type { DenoRelease } from \"../schemas/deno-release.js\";\nimport { DenoReleaseCache } from \"../services/DenoReleaseCache.js\";\nimport { createRuntimeCache } from \"./RuntimeCacheLive.js\";\n\n/**\n * Low-level layer that constructs the {@link DenoReleaseCache} 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 AutoDenoCacheLive} — API with fallback to bundled defaults\n * - {@link FreshDenoCacheLive} — API only, fails if unavailable\n * - {@link OfflineDenoCacheLive} — bundled defaults only\n *\n * @see {@link DenoReleaseCache}\n * @see {@link createRuntimeCache}\n * @internal\n */\nexport const DenoReleaseCacheLive: Layer.Layer<DenoReleaseCache, never, SemVerVersionCache> = Layer.effect(\n\tDenoReleaseCache,\n\tcreateRuntimeCache<DenoRelease>(),\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,uBAAiF,MAAM,OACnG,kBACA,mBAAgC,CACjC"}

package/layers/DenoResolverLive.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"DenoResolverLive.js","names":[],"sources":["../../../../src/layers/DenoResolverLive.ts"],"sourcesContent":["import { Effect, Layer } from \"effect\";\nimport { SemVer } from \"semver-effect\";\nimport { VersionNotFoundError } from \"../errors/VersionNotFoundError.js\";\nimport type { Increments } from \"../schemas/common.js\";\nimport type { DenoRelease } from \"../schemas/deno-release.js\";\nimport { DenoReleaseCache } from \"../services/DenoReleaseCache.js\";\nimport type { DenoResolverOptions } from \"../services/DenoResolver.js\";\nimport { DenoResolver } from \"../services/DenoResolver.js\";\n\n/**\n * Provides the {@link DenoResolver} service backed by a {@link DenoReleaseCache}.\n *\n * This layer composes with any of the three Deno cache strategy layers to form\n * a complete resolver stack. It implements semver range filtering and increment\n * grouping (latest per major, latest per minor, or all patch versions) using\n * the releases already loaded into the cache.\n *\n * @example\n * ```ts\n * import { DenoResolverLive, AutoDenoCacheLive, DenoVersionFetcherLive, GitHubClientLive, GitHubAutoAuth } from \"runtime-resolver\";\n * import { DenoResolver } from \"runtime-resolver\";\n * import { Effect, Layer } from \"effect\";\n *\n * const GitHubLayer = GitHubClientLive.pipe(Layer.provide(GitHubAutoAuth));\n * const CacheLayer = AutoDenoCacheLive.pipe(Layer.provide(DenoVersionFetcherLive.pipe(Layer.provide(GitHubLayer))));\n * const ResolverLayer = DenoResolverLive.pipe(Layer.provide(CacheLayer));\n *\n * const program = Effect.gen(function* () {\n *   const resolver = yield* DenoResolver;\n *   const result = yield* resolver.resolve({ semverRange: \"^2.0.0\" });\n *   console.log(result.latest);\n * });\n *\n * Effect.runPromise(program.pipe(Effect.provide(ResolverLayer)));\n * ```\n *\n * @see {@link DenoResolver}\n * @see {@link DenoReleaseCache}\n * @see {@link AutoDenoCacheLive}\n * @see {@link FreshDenoCacheLive}\n * @see {@link OfflineDenoCacheLive}\n * @public\n */\nexport const DenoResolverLive: Layer.Layer<DenoResolver, never, DenoReleaseCache> = Layer.effect(\n\tDenoResolver,\n\tEffect.gen(function* () {\n\t\tconst cache = yield* DenoReleaseCache;\n\n\t\treturn {\n\t\t\tresolve: (options?: DenoResolverOptions) =>\n\t\t\t\tEffect.gen(function* () {\n\t\t\t\t\tconst semverRange = options?.semverRange ?? \"*\";\n\t\t\t\t\tconst increments: Increments = options?.increments ?? \"latest\";\n\n\t\t\t\t\tconst matching = yield* cache\n\t\t\t\t\t\t.filter(semverRange)\n\t\t\t\t\t\t.pipe(Effect.catchAll(() => Effect.succeed([] as ReadonlyArray<DenoRelease>)));\n\n\t\t\t\t\tlet resultReleases: DenoRelease[];\n\t\t\t\t\tif (increments === \"latest\") {\n\t\t\t\t\t\tconst groups = new Map<number, DenoRelease>();\n\t\t\t\t\t\tfor (const r of matching) {\n\t\t\t\t\t\t\tconst existing = groups.get(r.version.major);\n\t\t\t\t\t\t\tif (!existing || SemVer.gt(r.version, existing.version)) {\n\t\t\t\t\t\t\t\tgroups.set(r.version.major, r);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tresultReleases = [...groups.values()];\n\t\t\t\t\t} else if (increments === \"minor\") {\n\t\t\t\t\t\tconst groups = new Map<string, DenoRelease>();\n\t\t\t\t\t\tfor (const r of matching) {\n\t\t\t\t\t\t\tconst key = `${r.version.major}.${r.version.minor}`;\n\t\t\t\t\t\t\tconst existing = groups.get(key);\n\t\t\t\t\t\t\tif (!existing || SemVer.gt(r.version, existing.version)) {\n\t\t\t\t\t\t\t\tgroups.set(key, r);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tresultReleases = [...groups.values()];\n\t\t\t\t\t} else {\n\t\t\t\t\t\tresultReleases = [...matching];\n\t\t\t\t\t}\n\n\t\t\t\t\tif (resultReleases.length === 0) {\n\t\t\t\t\t\treturn yield* Effect.fail(\n\t\t\t\t\t\t\tnew VersionNotFoundError({\n\t\t\t\t\t\t\t\truntime: \"deno\",\n\t\t\t\t\t\t\t\tconstraint: semverRange,\n\t\t\t\t\t\t\t\tmessage: `No Deno versions found matching \"${semverRange}\"`,\n\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\n\t\t\t\t\tconst sorted = SemVer.rsort(resultReleases.map((r) => r.version));\n\t\t\t\t\tconst versions = sorted.map((v) => v.toString());\n\t\t\t\t\tconst latest = versions[0];\n\n\t\t\t\t\tlet resolvedDefault: string | undefined;\n\t\t\t\t\tif (options?.defaultVersion) {\n\t\t\t\t\t\tresolvedDefault = yield* cache.resolve(options.defaultVersion).pipe(\n\t\t\t\t\t\t\tEffect.map((r) => r.version.toString()),\n\t\t\t\t\t\t\tEffect.catchAll(() => Effect.succeed(undefined)),\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\n\t\t\t\t\treturn {\n\t\t\t\t\t\tsource: \"api\" as const,\n\t\t\t\t\t\tversions,\n\t\t\t\t\t\tlatest,\n\t\t\t\t\t\t...(resolvedDefault ? { default: resolvedDefault } : {}),\n\t\t\t\t\t};\n\t\t\t\t}),\n\t\t};\n\t}),\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,MAAa,mBAAuE,MAAM,OACzF,cACA,OAAO,IAAI,aAAa;CACvB,MAAM,QAAQ,OAAO;CAErB,OAAO,EACN,UAAU,YACT,OAAO,IAAI,aAAa;EACvB,MAAM,cAAc,SAAS,eAAe;EAC5C,MAAM,aAAyB,SAAS,cAAc;EAEtD,MAAM,WAAW,OAAO,MACtB,OAAO,WAAW,CAAC,CACnB,KAAK,OAAO,eAAe,OAAO,QAAQ,CAAC,CAA+B,CAAC,CAAC;EAE9E,IAAI;EACJ,IAAI,eAAe,UAAU;GAC5B,MAAM,yBAAS,IAAI,IAAyB;GAC5C,KAAK,MAAM,KAAK,UAAU;IACzB,MAAM,WAAW,OAAO,IAAI,EAAE,QAAQ,KAAK;IAC3C,IAAI,CAAC,YAAY,OAAO,GAAG,EAAE,SAAS,SAAS,OAAO,GACrD,OAAO,IAAI,EAAE,QAAQ,OAAO,CAAC;GAE/B;GACA,iBAAiB,CAAC,GAAG,OAAO,OAAO,CAAC;EACrC,OAAO,IAAI,eAAe,SAAS;GAClC,MAAM,yBAAS,IAAI,IAAyB;GAC5C,KAAK,MAAM,KAAK,UAAU;IACzB,MAAM,MAAM,GAAG,EAAE,QAAQ,MAAM,GAAG,EAAE,QAAQ;IAC5C,MAAM,WAAW,OAAO,IAAI,GAAG;IAC/B,IAAI,CAAC,YAAY,OAAO,GAAG,EAAE,SAAS,SAAS,OAAO,GACrD,OAAO,IAAI,KAAK,CAAC;GAEnB;GACA,iBAAiB,CAAC,GAAG,OAAO,OAAO,CAAC;EACrC,OACC,iBAAiB,CAAC,GAAG,QAAQ;EAG9B,IAAI,eAAe,WAAW,GAC7B,OAAO,OAAO,OAAO,KACpB,IAAI,qBAAqB;GACxB,SAAS;GACT,YAAY;GACZ,SAAS,oCAAoC,YAAY;EAC1D,CAAC,CACF;EAID,MAAM,WADS,OAAO,MAAM,eAAe,KAAK,MAAM,EAAE,OAAO,CACzC,CAAC,CAAC,KAAK,MAAM,EAAE,SAAS,CAAC;EAC/C,MAAM,SAAS,SAAS;EAExB,IAAI;EACJ,IAAI,SAAS,gBACZ,kBAAkB,OAAO,MAAM,QAAQ,QAAQ,cAAc,CAAC,CAAC,KAC9D,OAAO,KAAK,MAAM,EAAE,QAAQ,SAAS,CAAC,GACtC,OAAO,eAAe,OAAO,QAAQ,MAAS,CAAC,CAChD;EAGD,OAAO;GACN,QAAQ;GACR;GACA;GACA,GAAI,kBAAkB,EAAE,SAAS,gBAAgB,IAAI,CAAC;EACvD;CACD,CAAC,EACH;AACD,CAAC,CACF"}

package/layers/DenoVersionFetcherLive.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"DenoVersionFetcherLive.js","names":[],"sources":["../../../../src/layers/DenoVersionFetcherLive.ts"],"sourcesContent":["import { Effect, Layer, Option } from \"effect\";\nimport { retryOnRateLimit } from \"../lib/retry.js\";\nimport { tryParseSemVer } from \"../lib/semver.js\";\nimport type { RuntimeReleaseInput } from \"../schemas/runtime-release.js\";\nimport { DenoVersionFetcher } from \"../services/DenoVersionFetcher.js\";\nimport { GitHubClient } from \"../services/GitHubClient.js\";\n\n/**\n * Provides the {@link DenoVersionFetcher} service using the live GitHub API.\n *\n * Fetches Deno releases from the `denoland/deno` GitHub repository using the\n * provided {@link GitHubClient}. Draft releases and pre-releases are excluded.\n * Tag names are normalized by stripping any leading `v` before parsing as\n * semver.\n *\n * This layer is a required dependency of {@link AutoDenoCacheLive} and\n * {@link FreshDenoCacheLive}. It is not needed by {@link OfflineDenoCacheLive}.\n *\n * @see {@link DenoVersionFetcher}\n * @see {@link GitHubClient}\n * @see {@link AutoDenoCacheLive}\n * @see {@link FreshDenoCacheLive}\n * @public\n */\nexport const DenoVersionFetcherLive: Layer.Layer<DenoVersionFetcher, never, GitHubClient> = Layer.effect(\n\tDenoVersionFetcher,\n\tEffect.gen(function* () {\n\t\tconst client = yield* GitHubClient;\n\n\t\treturn {\n\t\t\tfetch: () =>\n\t\t\t\tEffect.gen(function* () {\n\t\t\t\t\tconst releases = yield* retryOnRateLimit(client.listReleases(\"denoland\", \"deno\", { perPage: 100, pages: 3 }));\n\t\t\t\t\tconst fallbackDate = new Date().toISOString().slice(0, 10);\n\n\t\t\t\t\tconst parsed = yield* Effect.forEach(\n\t\t\t\t\t\treleases.filter((r) => !r.draft && !r.prerelease),\n\t\t\t\t\t\t(release) => {\n\t\t\t\t\t\t\tconst stripped = release.tag_name.startsWith(\"v\") ? release.tag_name.slice(1) : release.tag_name;\n\t\t\t\t\t\t\treturn tryParseSemVer(stripped).pipe(\n\t\t\t\t\t\t\t\tEffect.map((opt) =>\n\t\t\t\t\t\t\t\t\tOption.isSome(opt)\n\t\t\t\t\t\t\t\t\t\t? Option.some({\n\t\t\t\t\t\t\t\t\t\t\t\tversion: opt.value,\n\t\t\t\t\t\t\t\t\t\t\t\tinput: {\n\t\t\t\t\t\t\t\t\t\t\t\t\tversion: stripped,\n\t\t\t\t\t\t\t\t\t\t\t\t\tdate: release.published_at ?? fallbackDate,\n\t\t\t\t\t\t\t\t\t\t\t\t} satisfies RuntimeReleaseInput,\n\t\t\t\t\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t\t\t\t: Option.none(),\n\t\t\t\t\t\t\t\t),\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t},\n\t\t\t\t\t\t{ concurrency: \"unbounded\" },\n\t\t\t\t\t);\n\n\t\t\t\t\tconst versions = parsed.flatMap(Option.toArray).map(({ version }) => version);\n\t\t\t\t\tconst inputs = parsed.flatMap(Option.toArray).map(({ input }) => input);\n\n\t\t\t\t\treturn { versions, inputs };\n\t\t\t\t}),\n\t\t};\n\t}),\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAwBA,MAAa,yBAA+E,MAAM,OACjG,oBACA,OAAO,IAAI,aAAa;CACvB,MAAM,SAAS,OAAO;CAEtB,OAAO,EACN,aACC,OAAO,IAAI,aAAa;EACvB,MAAM,WAAW,OAAO,iBAAiB,OAAO,aAAa,YAAY,QAAQ;GAAE,SAAS;GAAK,OAAO;EAAE,CAAC,CAAC;EAC5G,MAAM,gCAAe,IAAI,KAAK,EAAC,CAAC,YAAY,CAAC,CAAC,MAAM,GAAG,EAAE;EAEzD,MAAM,SAAS,OAAO,OAAO,QAC5B,SAAS,QAAQ,MAAM,CAAC,EAAE,SAAS,CAAC,EAAE,UAAU,IAC/C,YAAY;GACZ,MAAM,WAAW,QAAQ,SAAS,WAAW,GAAG,IAAI,QAAQ,SAAS,MAAM,CAAC,IAAI,QAAQ;GACxF,OAAO,eAAe,QAAQ,CAAC,CAAC,KAC/B,OAAO,KAAK,QACX,OAAO,OAAO,GAAG,IACd,OAAO,KAAK;IACZ,SAAS,IAAI;IACb,OAAO;KACN,SAAS;KACT,MAAM,QAAQ,gBAAgB;IAC/B;GACD,CAAC,IACA,OAAO,KAAK,CAChB,CACD;EACD,GACA,EAAE,aAAa,YAAY,CAC5B;EAKA,OAAO;GAAE,UAHQ,OAAO,QAAQ,OAAO,OAAO,CAAC,CAAC,KAAK,EAAE,cAAc,OAGrD;GAAG,QAFJ,OAAO,QAAQ,OAAO,OAAO,CAAC,CAAC,KAAK,EAAE,YAAY,KAEzC;EAAE;CAC3B,CAAC,EACH;AACD,CAAC,CACF"}

package/layers/FreshBunCacheLive.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"FreshBunCacheLive.js","names":["SemVerVersionCacheLive"],"sources":["../../../../src/layers/FreshBunCacheLive.ts"],"sourcesContent":["import { Effect, Layer } from \"effect\";\nimport { SemVerParserLive, VersionCacheLive as SemVerVersionCacheLive } from \"semver-effect\";\nimport { FreshnessError } from \"../errors/FreshnessError.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 freshSetup = Effect.gen(function* () {\n\tconst cache = yield* BunReleaseCache;\n\tconst fetcher = yield* BunVersionFetcher;\n\n\tconst { inputs } = yield* fetcher.fetch().pipe(\n\t\tEffect.catchTags({\n\t\t\tAuthenticationError: (err) =>\n\t\t\t\tEffect.fail(\n\t\t\t\t\tnew FreshnessError({\n\t\t\t\t\t\tstrategy: \"api\",\n\t\t\t\t\t\tmessage: `Fresh data required but authentication failed: ${err.message}`,\n\t\t\t\t\t}),\n\t\t\t\t),\n\t\t\tNetworkError: (err) =>\n\t\t\t\tEffect.fail(\n\t\t\t\t\tnew FreshnessError({\n\t\t\t\t\t\tstrategy: \"api\",\n\t\t\t\t\t\tmessage: `Fresh data required but network unavailable: ${err.message}`,\n\t\t\t\t\t}),\n\t\t\t\t),\n\t\t\tParseError: (err) =>\n\t\t\t\tEffect.fail(\n\t\t\t\t\tnew FreshnessError({ strategy: \"api\", message: `Fresh data required but parse failed: ${err.message}` }),\n\t\t\t\t),\n\t\t\tRateLimitError: (err) =>\n\t\t\t\tEffect.fail(\n\t\t\t\t\tnew FreshnessError({\n\t\t\t\t\t\tstrategy: \"api\",\n\t\t\t\t\t\tmessage: `Fresh data required but rate limit exceeded: ${err.message}`,\n\t\t\t\t\t}),\n\t\t\t\t),\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 \"Fresh\" cache strategy.\n *\n * Requires live release data from the GitHub API via {@link BunVersionFetcher}.\n * If the fetch fails for any reason — authentication errors, network errors,\n * parse errors, or rate-limit errors — the layer fails with a `FreshnessError`\n * rather than falling back to stale data.\n *\n * Use this strategy in contexts where working with outdated version data would\n * be incorrect or misleading, such as CI pipelines or tooling that must reflect\n * the true current state of Bun releases.\n *\n * The three Bun cache strategy layers are:\n * - {@link AutoBunCacheLive} — tries API first, falls back to bundled defaults on any error\n * - `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 AutoBunCacheLive}\n * @see {@link OfflineBunCacheLive}\n * @public\n */\nexport const FreshBunCacheLive: Layer.Layer<BunReleaseCache, FreshnessError, BunVersionFetcher> = BaseCacheLayer.pipe(\n\tLayer.tap((ctx) => freshSetup.pipe(Effect.provide(ctx))),\n);\n"],"mappings":";;;;;;;;;AAQA,MAAM,aAAa,OAAO,IAAI,aAAa;CAC1C,MAAM,QAAQ,OAAO;CAGrB,MAAM,EAAE,WAAW,QAAO,OAFH,kBAEU,CAAC,MAAM,CAAC,CAAC,KACzC,OAAO,UAAU;EAChB,sBAAsB,QACrB,OAAO,KACN,IAAI,eAAe;GAClB,UAAU;GACV,SAAS,kDAAkD,IAAI;EAChE,CAAC,CACF;EACD,eAAe,QACd,OAAO,KACN,IAAI,eAAe;GAClB,UAAU;GACV,SAAS,gDAAgD,IAAI;EAC9D,CAAC,CACF;EACD,aAAa,QACZ,OAAO,KACN,IAAI,eAAe;GAAE,UAAU;GAAO,SAAS,yCAAyC,IAAI;EAAU,CAAC,CACxG;EACD,iBAAiB,QAChB,OAAO,KACN,IAAI,eAAe;GAClB,UAAU;GACV,SAAS,gDAAgD,IAAI;EAC9D,CAAC,CACF;CACF,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;;;;;;;;;;;;;;;;;;;;;;;AAwB1E,MAAa,oBAAqF,eAAe,KAChH,MAAM,KAAK,QAAQ,WAAW,KAAK,OAAO,QAAQ,GAAG,CAAC,CAAC,CACxD"}

package/layers/FreshDenoCacheLive.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"FreshDenoCacheLive.js","names":["SemVerVersionCacheLive"],"sources":["../../../../src/layers/FreshDenoCacheLive.ts"],"sourcesContent":["import { Effect, Layer } from \"effect\";\nimport { SemVerParserLive, VersionCacheLive as SemVerVersionCacheLive } from \"semver-effect\";\nimport { FreshnessError } from \"../errors/FreshnessError.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 freshSetup = Effect.gen(function* () {\n\tconst cache = yield* DenoReleaseCache;\n\tconst fetcher = yield* DenoVersionFetcher;\n\n\tconst { inputs } = yield* fetcher.fetch().pipe(\n\t\tEffect.catchTags({\n\t\t\tAuthenticationError: (err) =>\n\t\t\t\tEffect.fail(\n\t\t\t\t\tnew FreshnessError({\n\t\t\t\t\t\tstrategy: \"api\",\n\t\t\t\t\t\tmessage: `Fresh data required but authentication failed: ${err.message}`,\n\t\t\t\t\t}),\n\t\t\t\t),\n\t\t\tNetworkError: (err) =>\n\t\t\t\tEffect.fail(\n\t\t\t\t\tnew FreshnessError({\n\t\t\t\t\t\tstrategy: \"api\",\n\t\t\t\t\t\tmessage: `Fresh data required but network unavailable: ${err.message}`,\n\t\t\t\t\t}),\n\t\t\t\t),\n\t\t\tParseError: (err) =>\n\t\t\t\tEffect.fail(\n\t\t\t\t\tnew FreshnessError({ strategy: \"api\", message: `Fresh data required but parse failed: ${err.message}` }),\n\t\t\t\t),\n\t\t\tRateLimitError: (err) =>\n\t\t\t\tEffect.fail(\n\t\t\t\t\tnew FreshnessError({\n\t\t\t\t\t\tstrategy: \"api\",\n\t\t\t\t\t\tmessage: `Fresh data required but rate limit exceeded: ${err.message}`,\n\t\t\t\t\t}),\n\t\t\t\t),\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 \"Fresh\" cache strategy.\n *\n * Requires live release data from the GitHub API via {@link DenoVersionFetcher}.\n * If the fetch fails for any reason — authentication errors, network errors,\n * parse errors, or rate-limit errors — the layer fails with a `FreshnessError`\n * rather than falling back to stale data.\n *\n * Use this strategy in contexts where working with outdated version data would\n * be incorrect or misleading, such as CI pipelines or tooling that must reflect\n * the true current state of Deno releases.\n *\n * The three Deno cache strategy layers are:\n * - {@link AutoDenoCacheLive} — tries API first, falls back to bundled defaults on any error\n * - `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 AutoDenoCacheLive}\n * @see {@link OfflineDenoCacheLive}\n * @public\n */\nexport const FreshDenoCacheLive: Layer.Layer<DenoReleaseCache, FreshnessError, DenoVersionFetcher> =\n\tBaseCacheLayer.pipe(Layer.tap((ctx) => freshSetup.pipe(Effect.provide(ctx))));\n"],"mappings":";;;;;;;;;AAQA,MAAM,aAAa,OAAO,IAAI,aAAa;CAC1C,MAAM,QAAQ,OAAO;CAGrB,MAAM,EAAE,WAAW,QAAO,OAFH,mBAEU,CAAC,MAAM,CAAC,CAAC,KACzC,OAAO,UAAU;EAChB,sBAAsB,QACrB,OAAO,KACN,IAAI,eAAe;GAClB,UAAU;GACV,SAAS,kDAAkD,IAAI;EAChE,CAAC,CACF;EACD,eAAe,QACd,OAAO,KACN,IAAI,eAAe;GAClB,UAAU;GACV,SAAS,gDAAgD,IAAI;EAC9D,CAAC,CACF;EACD,aAAa,QACZ,OAAO,KACN,IAAI,eAAe;GAAE,UAAU;GAAO,SAAS,yCAAyC,IAAI;EAAU,CAAC,CACxG;EACD,iBAAiB,QAChB,OAAO,KACN,IAAI,eAAe;GAClB,UAAU;GACV,SAAS,gDAAgD,IAAI;EAC9D,CAAC,CACF;CACF,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;;;;;;;;;;;;;;;;;;;;;;;AAwB3E,MAAa,qBACZ,eAAe,KAAK,MAAM,KAAK,QAAQ,WAAW,KAAK,OAAO,QAAQ,GAAG,CAAC,CAAC,CAAC"}

package/layers/FreshNodeCacheLive.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"FreshNodeCacheLive.js","names":["SemVerVersionCacheLive"],"sources":["../../../../src/layers/FreshNodeCacheLive.ts"],"sourcesContent":["import { Effect, Layer } from \"effect\";\nimport { SemVerParserLive, VersionCacheLive as SemVerVersionCacheLive } from \"semver-effect\";\nimport { FreshnessError } from \"../errors/FreshnessError.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 freshSetup = Effect.gen(function* () {\n\tconst cache = yield* NodeReleaseCache;\n\tconst versionFetcher = yield* NodeVersionFetcher;\n\tconst scheduleFetcher = yield* NodeScheduleFetcher;\n\n\tconst [fetchResult, scheduleData] = yield* Effect.all([versionFetcher.fetch(), scheduleFetcher.fetch()]).pipe(\n\t\tEffect.catchTags({\n\t\t\tNetworkError: (err) =>\n\t\t\t\tEffect.fail(\n\t\t\t\t\tnew FreshnessError({\n\t\t\t\t\t\tstrategy: \"api\",\n\t\t\t\t\t\tmessage: `Fresh data required but network unavailable: ${err.message}`,\n\t\t\t\t\t}),\n\t\t\t\t),\n\t\t\tParseError: (err) =>\n\t\t\t\tEffect.fail(\n\t\t\t\t\tnew FreshnessError({\n\t\t\t\t\t\tstrategy: \"api\",\n\t\t\t\t\t\tmessage: `Fresh data required but response could not be parsed: ${err.message}`,\n\t\t\t\t\t}),\n\t\t\t\t),\n\t\t}),\n\t);\n\n\tyield* cache.updateSchedule(scheduleData);\n\tyield* cache.loadFromInputs(fetchResult.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 \"Fresh\" cache strategy.\n *\n * Requires 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 fails with a `FreshnessError`\n * rather than falling back to stale data.\n *\n * Use this strategy in contexts where working with outdated version data would\n * be incorrect or misleading, such as CI pipelines or tooling that must reflect\n * the true current state of Node.js releases and LTS schedule.\n *\n * The three Node cache strategy layers are:\n * - {@link AutoNodeCacheLive} — tries API first, falls back to bundled defaults on any error\n * - `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 AutoNodeCacheLive}\n * @see {@link OfflineNodeCacheLive}\n * @public\n */\nexport const FreshNodeCacheLive: Layer.Layer<\n\tNodeReleaseCache,\n\tFreshnessError,\n\tNodeVersionFetcher | NodeScheduleFetcher\n> = BaseCacheLayer.pipe(Layer.tap((ctx) => freshSetup.pipe(Effect.provide(ctx))));\n"],"mappings":";;;;;;;;;AAQA,MAAM,aAAa,OAAO,IAAI,aAAa;CAC1C,MAAM,QAAQ,OAAO;CACrB,MAAM,iBAAiB,OAAO;CAC9B,MAAM,kBAAkB,OAAO;CAE/B,MAAM,CAAC,aAAa,gBAAgB,OAAO,OAAO,IAAI,CAAC,eAAe,MAAM,GAAG,gBAAgB,MAAM,CAAC,CAAC,CAAC,CAAC,KACxG,OAAO,UAAU;EAChB,eAAe,QACd,OAAO,KACN,IAAI,eAAe;GAClB,UAAU;GACV,SAAS,gDAAgD,IAAI;EAC9D,CAAC,CACF;EACD,aAAa,QACZ,OAAO,KACN,IAAI,eAAe;GAClB,UAAU;GACV,SAAS,yDAAyD,IAAI;EACvE,CAAC,CACF;CACF,CAAC,CACF;CAEA,OAAO,MAAM,eAAe,YAAY;CACxC,OAAO,MAAM,eAAe,YAAY,MAAM;AAC/C,CAAC;AAED,MAAM,cAAcA,iBAAuB,KAAK,MAAM,QAAQ,gBAAgB,CAAC;AAC/E,MAAM,iBAAiB,qBAAqB,KAAK,MAAM,QAAQ,WAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;AAyB3E,MAAa,qBAIT,eAAe,KAAK,MAAM,KAAK,QAAQ,WAAW,KAAK,OAAO,QAAQ,GAAG,CAAC,CAAC,CAAC"}

package/layers/GitHubAppAuth.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"GitHubAppAuth.js","names":[],"sources":["../../../../src/layers/GitHubAppAuth.ts"],"sourcesContent":["import { createAppAuth } from \"@octokit/auth-app\";\nimport { Effect, Layer } from \"effect\";\nimport { Octokit } from \"octokit\";\nimport { AuthenticationError } from \"../errors/AuthenticationError.js\";\nimport { OctokitInstance } from \"../services/OctokitInstance.js\";\n\n/**\n * Configuration required to authenticate as a GitHub App installation.\n *\n * @see {@link GitHubAppAuth}\n * @public\n */\nexport interface GitHubAppAuthConfig {\n\treadonly appId: string;\n\treadonly privateKey: string;\n\treadonly installationId?: number;\n}\n\nconst resolveInstallationId = async (\n\tauth: (opts: { type: \"app\" }) => Promise<{ token: string }>,\n\tinstallationId?: number,\n): Promise<number> => {\n\tif (installationId) return installationId;\n\n\tconst { token: jwt } = await auth({ type: \"app\" });\n\n\tconst response = await fetch(\"https://api.github.com/app/installations?per_page=100\", {\n\t\theaders: {\n\t\t\tAuthorization: `Bearer ${jwt}`,\n\t\t\tAccept: \"application/vnd.github+json\",\n\t\t},\n\t});\n\n\tif (!response.ok) {\n\t\tthrow new Error(`Failed to list installations: ${response.status}`);\n\t}\n\n\tconst installations = (await response.json()) as Array<{ id: number }>;\n\n\tif (installations.length === 0) {\n\t\tthrow new Error(\"No installations found for this GitHub App\");\n\t}\n\n\t// Use the first installation. Most apps have a single installation;\n\t// callers with multiple should pass installationId explicitly.\n\treturn installations[0].id;\n};\n\n/**\n * Provides an {@link OctokitInstance} authenticated as a GitHub App installation.\n *\n * Accepts a {@link GitHubAppAuthConfig} and uses `@octokit/auth-app` to obtain\n * an installation access token. If `installationId` is omitted, the first\n * installation returned by the GitHub API is used automatically (suitable for\n * apps with a single installation). If authentication fails for any reason the\n * layer fails with an `AuthenticationError`.\n *\n * Use this auth method when your integration runs as a GitHub App rather than\n * as an individual user or a CI token.\n *\n * @param config - App credentials and optional installation ID.\n *\n * @see {@link GitHubAppAuthConfig}\n * @see {@link OctokitInstance}\n * @see {@link GitHubAutoAuth}\n * @see {@link GitHubTokenAuth}\n * @public\n */\nexport const GitHubAppAuth = (config: GitHubAppAuthConfig): Layer.Layer<OctokitInstance, AuthenticationError> =>\n\tLayer.effect(\n\t\tOctokitInstance,\n\t\tEffect.tryPromise({\n\t\t\ttry: async () => {\n\t\t\t\tconst auth = createAppAuth({\n\t\t\t\t\tappId: config.appId,\n\t\t\t\t\tprivateKey: config.privateKey,\n\t\t\t\t});\n\n\t\t\t\tconst resolvedId = await resolveInstallationId(auth, config.installationId);\n\n\t\t\t\tconst result = await auth({\n\t\t\t\t\ttype: \"installation\",\n\t\t\t\t\tinstallationId: resolvedId,\n\t\t\t\t});\n\n\t\t\t\treturn new Octokit({ auth: result.token });\n\t\t\t},\n\t\t\tcatch: (error) =>\n\t\t\t\tnew AuthenticationError({\n\t\t\t\t\tmethod: \"app\",\n\t\t\t\t\tmessage: error instanceof Error ? error.message : String(error),\n\t\t\t\t}),\n\t\t}),\n\t);\n"],"mappings":";;;;;;;AAkBA,MAAM,wBAAwB,OAC7B,MACA,mBACqB;CACrB,IAAI,gBAAgB,OAAO;CAE3B,MAAM,EAAE,OAAO,QAAQ,MAAM,KAAK,EAAE,MAAM,MAAM,CAAC;CAEjD,MAAM,WAAW,MAAM,MAAM,yDAAyD,EACrF,SAAS;EACR,eAAe,UAAU;EACzB,QAAQ;CACT,EACD,CAAC;CAED,IAAI,CAAC,SAAS,IACb,MAAM,IAAI,MAAM,iCAAiC,SAAS,QAAQ;CAGnE,MAAM,gBAAiB,MAAM,SAAS,KAAK;CAE3C,IAAI,cAAc,WAAW,GAC5B,MAAM,IAAI,MAAM,4CAA4C;CAK7D,OAAO,cAAc,EAAE,CAAC;AACzB;;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,iBAAiB,WAC7B,MAAM,OACL,iBACA,OAAO,WAAW;CACjB,KAAK,YAAY;EAChB,MAAM,OAAO,cAAc;GAC1B,OAAO,OAAO;GACd,YAAY,OAAO;EACpB,CAAC;EASD,OAAO,IAAI,QAAQ,EAAE,OAAM,MALN,KAAK;GACzB,MAAM;GACN,gBAAgB,MAJQ,sBAAsB,MAAM,OAAO,cAAc;EAK1E,CAAC,EAEgC,CAAC,MAAM,CAAC;CAC1C;CACA,QAAQ,UACP,IAAI,oBAAoB;EACvB,QAAQ;EACR,SAAS,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;CAC/D,CAAC;AACH,CAAC,CACF"}

package/layers/GitHubAutoAuth.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"GitHubAutoAuth.js","names":[],"sources":["../../../../src/layers/GitHubAutoAuth.ts"],"sourcesContent":["import { Effect, Layer } from \"effect\";\nimport { Octokit } from \"octokit\";\nimport type { AuthenticationError } from \"../errors/AuthenticationError.js\";\nimport { OctokitInstance } from \"../services/OctokitInstance.js\";\nimport { GitHubAppAuth } from \"./GitHubAppAuth.js\";\n\n/**\n * Provides an {@link OctokitInstance} by auto-detecting the available\n * authentication credentials from environment variables at layer construction\n * time.\n *\n * Credentials are evaluated in the following priority order:\n * 1. **GitHub App** — when both `GITHUB_APP_ID` and `GITHUB_APP_PRIVATE_KEY`\n *    are set, authenticates as a GitHub App installation via {@link GitHubAppAuth}.\n *    `GITHUB_APP_INSTALLATION_ID` is optional; if absent the first installation\n *    is used automatically.\n * 2. **Personal Access Token** — when `GITHUB_PERSONAL_ACCESS_TOKEN` is set,\n *    authenticates with that token.\n * 3. **`GITHUB_TOKEN`** — when `GITHUB_TOKEN` is set (e.g., the default token\n *    injected in GitHub Actions), authenticates with that token.\n * 4. **Unauthenticated** — falls back to an unauthenticated Octokit instance\n *    when no credentials are found (lower rate limits apply).\n *\n * If both App and token credentials are present, App auth takes precedence and\n * a warning is logged. This layer fails with `AuthenticationError` only when\n * App credentials are present but the App authentication itself fails.\n *\n * Use this layer as the default auth strategy in most applications. Switch to\n * {@link GitHubTokenAuth} or {@link GitHubAppAuth} when you need explicit control\n * over which credential source is used.\n *\n * @example\n * ```ts\n * import { GitHubClientLive, GitHubAutoAuth } from \"runtime-resolver\";\n * import { Layer } from \"effect\";\n *\n * const GitHubLayer = GitHubClientLive.pipe(Layer.provide(GitHubAutoAuth));\n * ```\n *\n * @see {@link OctokitInstance}\n * @see {@link GitHubTokenAuth}\n * @see {@link GitHubAppAuth}\n * @public\n */\nexport const GitHubAutoAuth: Layer.Layer<OctokitInstance, AuthenticationError> = Layer.effect(\n\tOctokitInstance,\n\tEffect.gen(function* () {\n\t\tconst appId = process.env.GITHUB_APP_ID;\n\t\tconst privateKey = process.env.GITHUB_APP_PRIVATE_KEY;\n\t\tconst installationId = process.env.GITHUB_APP_INSTALLATION_ID;\n\t\tconst pat = process.env.GITHUB_PERSONAL_ACCESS_TOKEN;\n\t\tconst token = process.env.GITHUB_TOKEN;\n\n\t\tconst hasApp = appId && privateKey;\n\t\tconst hasToken = pat || token;\n\n\t\t// Warn when multiple credential sources are detected\n\t\tif (hasApp && hasToken) {\n\t\t\tconst tokenSource = pat ? \"GITHUB_PERSONAL_ACCESS_TOKEN\" : \"GITHUB_TOKEN\";\n\t\t\tyield* Effect.logWarning(\n\t\t\t\t`Multiple GitHub credential sources found. Using GitHub App authentication (from GITHUB_APP_ID). Ignoring ${tokenSource}.`,\n\t\t\t);\n\t\t}\n\n\t\t// Priority 1: App env vars\n\t\tif (hasApp) {\n\t\t\tconst appLayer = GitHubAppAuth({\n\t\t\t\tappId: appId,\n\t\t\t\tprivateKey: privateKey,\n\t\t\t\t...(installationId ? { installationId: Number(installationId) } : {}),\n\t\t\t});\n\t\t\treturn yield* Effect.provide(OctokitInstance, appLayer);\n\t\t}\n\n\t\t// Priority 2: Token env vars (PAT first, then GITHUB_TOKEN)\n\t\tif (pat) {\n\t\t\treturn new Octokit({ auth: pat });\n\t\t}\n\t\tif (token) {\n\t\t\treturn new Octokit({ auth: token });\n\t\t}\n\n\t\t// Priority 3: Unauthenticated\n\t\treturn new Octokit();\n\t}),\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,MAAa,iBAAoE,MAAM,OACtF,iBACA,OAAO,IAAI,aAAa;CACvB,MAAM,QAAQ,QAAQ,IAAI;CAC1B,MAAM,aAAa,QAAQ,IAAI;CAC/B,MAAM,iBAAiB,QAAQ,IAAI;CACnC,MAAM,MAAM,QAAQ,IAAI;CACxB,MAAM,QAAQ,QAAQ,IAAI;CAE1B,MAAM,SAAS,SAAS;CAIxB,IAAI,WAHa,OAAO,QAGA;EACvB,MAAM,cAAc,MAAM,iCAAiC;EAC3D,OAAO,OAAO,WACb,4GAA4G,YAAY,EACzH;CACD;CAGA,IAAI,QAAQ;EACX,MAAM,WAAW,cAAc;GACvB;GACK;GACZ,GAAI,iBAAiB,EAAE,gBAAgB,OAAO,cAAc,EAAE,IAAI,CAAC;EACpE,CAAC;EACD,OAAO,OAAO,OAAO,QAAQ,iBAAiB,QAAQ;CACvD;CAGA,IAAI,KACH,OAAO,IAAI,QAAQ,EAAE,MAAM,IAAI,CAAC;CAEjC,IAAI,OACH,OAAO,IAAI,QAAQ,EAAE,MAAM,MAAM,CAAC;CAInC,OAAO,IAAI,QAAQ;AACpB,CAAC,CACF"}

package/layers/GitHubClientLive.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"GitHubClientLive.js","names":[],"sources":["../../../../src/layers/GitHubClientLive.ts"],"sourcesContent":["import { Effect, Layer, Schema } from \"effect\";\nimport { AuthenticationError } from \"../errors/AuthenticationError.js\";\nimport { NetworkError } from \"../errors/NetworkError.js\";\nimport { ParseError } from \"../errors/ParseError.js\";\nimport { RateLimitError } from \"../errors/RateLimitError.js\";\nimport { GitHubReleaseList, GitHubTagList } from \"../schemas/github.js\";\nimport type { ListOptions } from \"../services/GitHubClient.js\";\nimport { GitHubClient } from \"../services/GitHubClient.js\";\nimport { OctokitInstance } from \"../services/OctokitInstance.js\";\n\nconst mapOctokitError = (error: unknown, url: string): NetworkError | RateLimitError | AuthenticationError => {\n\tconst err = error as { status?: number; response?: { headers?: Record<string, string> } };\n\n\tif (err.status === 401) {\n\t\treturn new AuthenticationError({\n\t\t\tmethod: \"token\",\n\t\t\tmessage: `GitHub API authentication failed for ${url}`,\n\t\t});\n\t}\n\n\tif (err.status === 403 || err.status === 429) {\n\t\tconst headers = err.response?.headers ?? {};\n\t\tconst retryAfterStr = headers[\"retry-after\"];\n\t\treturn new RateLimitError({\n\t\t\t...(retryAfterStr ? { retryAfter: Number.parseInt(retryAfterStr, 10) } : {}),\n\t\t\tlimit: headers[\"x-ratelimit-limit\"] ? Number.parseInt(headers[\"x-ratelimit-limit\"], 10) : 0,\n\t\t\tremaining: headers[\"x-ratelimit-remaining\"] ? Number.parseInt(headers[\"x-ratelimit-remaining\"], 10) : 0,\n\t\t\tmessage: `GitHub API rate limit exceeded for ${url}`,\n\t\t});\n\t}\n\n\treturn new NetworkError({\n\t\turl,\n\t\t...(err.status !== undefined ? { status: err.status } : {}),\n\t\tmessage: error instanceof Error ? error.message : String(error),\n\t});\n};\n\nconst decodeTagList = Schema.decodeUnknown(GitHubTagList);\nconst decodeReleaseList = Schema.decodeUnknown(GitHubReleaseList);\n\n/**\n * Provides the {@link GitHubClient} service backed by an {@link OctokitInstance}.\n *\n * This layer wraps an Octokit instance and exposes a typed, Effect-native API\n * for listing GitHub releases, listing tags, and fetching arbitrary JSON from\n * URLs. HTTP errors are mapped to typed domain errors (`NetworkError`,\n * `RateLimitError`, `AuthenticationError`) so they can be handled precisely in\n * calling code.\n *\n * Pair this layer with one of the auth layers to form a complete GitHub\n * integration stack:\n * - {@link GitHubAutoAuth} — auto-detects auth from environment variables\n * - {@link GitHubTokenAuth} — authenticates using a personal access token\n * - {@link GitHubAppAuth} — authenticates as a GitHub App installation\n *\n * @see {@link GitHubClient}\n * @see {@link OctokitInstance}\n * @see {@link GitHubAutoAuth}\n * @public\n */\nexport const GitHubClientLive: Layer.Layer<GitHubClient, never, OctokitInstance> = Layer.effect(\n\tGitHubClient,\n\tEffect.gen(function* () {\n\t\tconst octokit = yield* OctokitInstance;\n\n\t\treturn {\n\t\t\tlistTags: (owner, repo, options?: ListOptions) =>\n\t\t\t\tEffect.gen(function* () {\n\t\t\t\t\tconst perPage = options?.perPage ?? 100;\n\t\t\t\t\tconst maxPages = options?.pages ?? Number.POSITIVE_INFINITY;\n\t\t\t\t\tconst allTags: Array<(typeof GitHubTagList.Type)[number]> = [];\n\n\t\t\t\t\tfor (let page = 1; page <= maxPages; page++) {\n\t\t\t\t\t\tconst response = yield* Effect.tryPromise({\n\t\t\t\t\t\t\ttry: () =>\n\t\t\t\t\t\t\t\toctokit.rest.repos.listTags({\n\t\t\t\t\t\t\t\t\towner,\n\t\t\t\t\t\t\t\t\trepo,\n\t\t\t\t\t\t\t\t\tper_page: perPage,\n\t\t\t\t\t\t\t\t\tpage,\n\t\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t\tcatch: (error) => mapOctokitError(error, `repos/${owner}/${repo}/tags`),\n\t\t\t\t\t\t});\n\n\t\t\t\t\t\tconst tags = yield* decodeTagList(response.data).pipe(\n\t\t\t\t\t\t\tEffect.mapError(\n\t\t\t\t\t\t\t\t(e) =>\n\t\t\t\t\t\t\t\t\tnew ParseError({\n\t\t\t\t\t\t\t\t\t\tsource: `repos/${owner}/${repo}/tags`,\n\t\t\t\t\t\t\t\t\t\tmessage: `Schema validation failed: ${e.message}`,\n\t\t\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t\t),\n\t\t\t\t\t\t);\n\n\t\t\t\t\t\tallTags.push(...tags);\n\n\t\t\t\t\t\tif (response.data.length < perPage) break;\n\t\t\t\t\t}\n\n\t\t\t\t\treturn allTags;\n\t\t\t\t}),\n\n\t\t\tlistReleases: (owner, repo, options?: ListOptions) =>\n\t\t\t\tEffect.gen(function* () {\n\t\t\t\t\tconst perPage = options?.perPage ?? 100;\n\t\t\t\t\tconst maxPages = options?.pages ?? Number.POSITIVE_INFINITY;\n\t\t\t\t\tconst allReleases: Array<(typeof GitHubReleaseList.Type)[number]> = [];\n\n\t\t\t\t\tfor (let page = 1; page <= maxPages; page++) {\n\t\t\t\t\t\tconst response = yield* Effect.tryPromise({\n\t\t\t\t\t\t\ttry: () =>\n\t\t\t\t\t\t\t\toctokit.rest.repos.listReleases({\n\t\t\t\t\t\t\t\t\towner,\n\t\t\t\t\t\t\t\t\trepo,\n\t\t\t\t\t\t\t\t\tper_page: perPage,\n\t\t\t\t\t\t\t\t\tpage,\n\t\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t\tcatch: (error) => mapOctokitError(error, `repos/${owner}/${repo}/releases`),\n\t\t\t\t\t\t});\n\n\t\t\t\t\t\tconst releases = yield* decodeReleaseList(response.data).pipe(\n\t\t\t\t\t\t\tEffect.mapError(\n\t\t\t\t\t\t\t\t(e) =>\n\t\t\t\t\t\t\t\t\tnew ParseError({\n\t\t\t\t\t\t\t\t\t\tsource: `repos/${owner}/${repo}/releases`,\n\t\t\t\t\t\t\t\t\t\tmessage: `Schema validation failed: ${e.message}`,\n\t\t\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t\t),\n\t\t\t\t\t\t);\n\n\t\t\t\t\t\tallReleases.push(...releases);\n\n\t\t\t\t\t\tif (response.data.length < perPage) break;\n\t\t\t\t\t}\n\n\t\t\t\t\treturn allReleases;\n\t\t\t\t}),\n\n\t\t\tgetJson: <A>(url: string, schema: { readonly decode: (input: unknown) => Effect.Effect<A, ParseError> }) =>\n\t\t\t\tEffect.gen(function* () {\n\t\t\t\t\tconst response = yield* Effect.tryPromise({\n\t\t\t\t\t\ttry: () => fetch(url),\n\t\t\t\t\t\tcatch: (error) =>\n\t\t\t\t\t\t\tnew NetworkError({\n\t\t\t\t\t\t\t\turl,\n\t\t\t\t\t\t\t\tmessage: error instanceof Error ? error.message : String(error),\n\t\t\t\t\t\t\t}),\n\t\t\t\t\t});\n\n\t\t\t\t\tif (!response.ok) {\n\t\t\t\t\t\tyield* Effect.fail(\n\t\t\t\t\t\t\tnew NetworkError({\n\t\t\t\t\t\t\t\turl,\n\t\t\t\t\t\t\t\tstatus: response.status,\n\t\t\t\t\t\t\t\tmessage: `HTTP ${response.status}: ${response.statusText}`,\n\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\n\t\t\t\t\tconst json = yield* Effect.tryPromise({\n\t\t\t\t\t\ttry: () => response.json(),\n\t\t\t\t\t\tcatch: () =>\n\t\t\t\t\t\t\tnew ParseError({\n\t\t\t\t\t\t\t\tsource: url,\n\t\t\t\t\t\t\t\tmessage: \"Failed to parse JSON response\",\n\t\t\t\t\t\t\t}),\n\t\t\t\t\t});\n\n\t\t\t\t\treturn yield* schema.decode(json);\n\t\t\t\t}),\n\t\t};\n\t}),\n);\n"],"mappings":"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"}

package/layers/GitHubTokenAuth.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"GitHubTokenAuth.js","names":[],"sources":["../../../../src/layers/GitHubTokenAuth.ts"],"sourcesContent":["import { Effect, Layer } from \"effect\";\nimport { Octokit } from \"octokit\";\nimport { OctokitInstance } from \"../services/OctokitInstance.js\";\n\nconst resolveToken = Effect.sync(\n\t(): string => process.env.GITHUB_PERSONAL_ACCESS_TOKEN || process.env.GITHUB_TOKEN || \"\",\n);\n\n/**\n * Provides an {@link OctokitInstance} authenticated with a GitHub personal\n * access token read from the environment at layer construction time.\n *\n * The token is resolved by checking, in order:\n * 1. `GITHUB_PERSONAL_ACCESS_TOKEN` environment variable\n * 2. `GITHUB_TOKEN` environment variable\n *\n * If neither variable is set the layer constructs an unauthenticated Octokit\n * instance (lower rate limits apply). This layer never fails.\n *\n * Use {@link GitHubTokenAuthFromToken} when you have the token value available\n * programmatically at construction time.\n *\n * @see {@link OctokitInstance}\n * @see {@link GitHubTokenAuthFromToken}\n * @see {@link GitHubAutoAuth}\n * @see {@link GitHubAppAuth}\n * @public\n */\nexport const GitHubTokenAuth: Layer.Layer<OctokitInstance> = Layer.effect(\n\tOctokitInstance,\n\tEffect.gen(function* () {\n\t\tconst token = yield* resolveToken;\n\t\treturn new Octokit(token ? { auth: token } : {});\n\t}),\n);\n\n/**\n * Provides an {@link OctokitInstance} authenticated with the given personal\n * access token string.\n *\n * Use this variant when the token is available as a value in your program\n * rather than read from an environment variable. The resulting layer never\n * fails.\n *\n * @param token - A GitHub personal access token string.\n *\n * @see {@link OctokitInstance}\n * @see {@link GitHubTokenAuth}\n * @see {@link GitHubAutoAuth}\n * @see {@link GitHubAppAuth}\n * @public\n */\nexport const GitHubTokenAuthFromToken = (token: string): Layer.Layer<OctokitInstance> =>\n\tLayer.succeed(OctokitInstance, new Octokit({ auth: token }));\n"],"mappings":";;;;;AAIA,MAAM,eAAe,OAAO,WACb,QAAQ,IAAI,gCAAgC,QAAQ,IAAI,gBAAgB,EACvF;;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,kBAAgD,MAAM,OAClE,iBACA,OAAO,IAAI,aAAa;CACvB,MAAM,QAAQ,OAAO;CACrB,OAAO,IAAI,QAAQ,QAAQ,EAAE,MAAM,MAAM,IAAI,CAAC,CAAC;AAChD,CAAC,CACF;;;;;;;;;;;;;;;;;AAkBA,MAAa,4BAA4B,UACxC,MAAM,QAAQ,iBAAiB,IAAI,QAAQ,EAAE,MAAM,MAAM,CAAC,CAAC"}

package/layers/NodeReleaseCacheLive.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"NodeReleaseCacheLive.js","names":[],"sources":["../../../../src/layers/NodeReleaseCacheLive.ts"],"sourcesContent":["import type { DateTime } from \"effect\";\nimport { Effect, Layer, Ref } from \"effect\";\nimport type { VersionCache as SemVerVersionCache } from \"semver-effect\";\nimport type { NodeReleaseInput } from \"../schemas/node-release.js\";\nimport { NodeRelease } from \"../schemas/node-release.js\";\nimport type { NodeScheduleData } from \"../schemas/node-schedule.js\";\nimport { NodeSchedule } from \"../schemas/node-schedule.js\";\nimport { NodeReleaseCache } from \"../services/NodeReleaseCache.js\";\nimport { createRuntimeCache } from \"./RuntimeCacheLive.js\";\n\n/**\n * Low-level layer that constructs the {@link NodeReleaseCache} service backed by\n * a `SemVerVersionCache` instance from `semver-effect`.\n *\n * This layer is more complex than the Bun and Deno equivalents because it manages\n * additional LTS schedule state via an internal `Ref`. The schedule is stored\n * separately from the version list so that calling `updateSchedule` can\n * transparently rebuild all release objects with the latest phase information\n * without reloading data from the network.\n *\n * This layer wires up the cache storage but does not populate it with any\n * release data. Callers are responsible for calling `updateSchedule` and\n * `loadFromInputs` after construction. In normal usage you should prefer the\n * higher-level cache strategy layers instead of using this layer directly:\n * - {@link AutoNodeCacheLive} — API with fallback to bundled defaults\n * - {@link FreshNodeCacheLive} — API only, fails if unavailable\n * - {@link OfflineNodeCacheLive} — bundled defaults only\n *\n * @see {@link NodeReleaseCache}\n * @see {@link createRuntimeCache}\n * @internal\n */\nexport const NodeReleaseCacheLive: Layer.Layer<NodeReleaseCache, never, SemVerVersionCache> = Layer.effect(\n\tNodeReleaseCache,\n\tEffect.gen(function* () {\n\t\tconst scheduleRef = yield* Ref.make(NodeSchedule.fromData({}));\n\t\tconst inner = yield* createRuntimeCache<NodeRelease>();\n\n\t\t// Held separately so we can rebuild releases when schedule updates\n\t\tlet currentInputs: ReadonlyArray<NodeReleaseInput> = [];\n\n\t\tconst buildAndLoad = (inputs: ReadonlyArray<NodeReleaseInput>) =>\n\t\t\tEffect.gen(function* () {\n\t\t\t\tconst releases: NodeRelease[] = [];\n\t\t\t\tfor (const input of inputs) {\n\t\t\t\t\tconst release = yield* NodeRelease.fromInput(input, scheduleRef).pipe(\n\t\t\t\t\t\tEffect.catchAll(() => Effect.succeed(null)),\n\t\t\t\t\t);\n\t\t\t\t\tif (release) releases.push(release);\n\t\t\t\t}\n\t\t\t\tyield* inner.load(releases);\n\t\t\t});\n\n\t\treturn {\n\t\t\t// -- RuntimeCache<NodeRelease> delegation --\n\t\t\tload: (releases) => inner.load(releases),\n\t\t\tresolve: (range) => inner.resolve(range),\n\t\t\treleases: () => inner.releases(),\n\t\t\tfilter: (range) => inner.filter(range),\n\t\t\tlatest: () => inner.latest(),\n\t\t\tlatestByMajor: () => inner.latestByMajor(),\n\t\t\tlatestByMinor: () => inner.latestByMinor(),\n\n\t\t\t// -- Node-specific --\n\t\t\tupdateSchedule: (data: NodeScheduleData) =>\n\t\t\t\tEffect.gen(function* () {\n\t\t\t\t\tyield* Ref.set(scheduleRef, NodeSchedule.fromData(data));\n\t\t\t\t\t// Rebuild releases if we have stored inputs\n\t\t\t\t\tif (currentInputs.length > 0) {\n\t\t\t\t\t\tyield* buildAndLoad(currentInputs);\n\t\t\t\t\t}\n\t\t\t\t}),\n\n\t\t\tloadFromInputs: (inputs: ReadonlyArray<NodeReleaseInput>) =>\n\t\t\t\tEffect.gen(function* () {\n\t\t\t\t\tcurrentInputs = inputs;\n\t\t\t\t\tyield* buildAndLoad(inputs);\n\t\t\t\t}),\n\n\t\t\tltsReleases: (now?: DateTime.DateTime) =>\n\t\t\t\tEffect.gen(function* () {\n\t\t\t\t\tconst all = yield* inner.releases();\n\t\t\t\t\tconst results: NodeRelease[] = [];\n\t\t\t\t\tfor (const r of all) {\n\t\t\t\t\t\tconst phase = yield* r.phase(now);\n\t\t\t\t\t\tif (phase === \"active-lts\" || phase === \"maintenance-lts\") {\n\t\t\t\t\t\t\tresults.push(r);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\treturn results;\n\t\t\t\t}),\n\n\t\t\tcurrentReleases: (now?: DateTime.DateTime) =>\n\t\t\t\tEffect.gen(function* () {\n\t\t\t\t\tconst all = yield* inner.releases();\n\t\t\t\t\tconst results: NodeRelease[] = [];\n\t\t\t\t\tfor (const r of all) {\n\t\t\t\t\t\tconst phase = yield* r.phase(now);\n\t\t\t\t\t\tif (phase === \"current\") {\n\t\t\t\t\t\t\tresults.push(r);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\treturn results;\n\t\t\t\t}),\n\t\t};\n\t}),\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,MAAa,uBAAiF,MAAM,OACnG,kBACA,OAAO,IAAI,aAAa;CACvB,MAAM,cAAc,OAAO,IAAI,KAAK,aAAa,SAAS,CAAC,CAAC,CAAC;CAC7D,MAAM,QAAQ,OAAO,mBAAgC;CAGrD,IAAI,gBAAiD,CAAC;CAEtD,MAAM,gBAAgB,WACrB,OAAO,IAAI,aAAa;EACvB,MAAM,WAA0B,CAAC;EACjC,KAAK,MAAM,SAAS,QAAQ;GAC3B,MAAM,UAAU,OAAO,YAAY,UAAU,OAAO,WAAW,CAAC,CAAC,KAChE,OAAO,eAAe,OAAO,QAAQ,IAAI,CAAC,CAC3C;GACA,IAAI,SAAS,SAAS,KAAK,OAAO;EACnC;EACA,OAAO,MAAM,KAAK,QAAQ;CAC3B,CAAC;CAEF,OAAO;EAEN,OAAO,aAAa,MAAM,KAAK,QAAQ;EACvC,UAAU,UAAU,MAAM,QAAQ,KAAK;EACvC,gBAAgB,MAAM,SAAS;EAC/B,SAAS,UAAU,MAAM,OAAO,KAAK;EACrC,cAAc,MAAM,OAAO;EAC3B,qBAAqB,MAAM,cAAc;EACzC,qBAAqB,MAAM,cAAc;EAGzC,iBAAiB,SAChB,OAAO,IAAI,aAAa;GACvB,OAAO,IAAI,IAAI,aAAa,aAAa,SAAS,IAAI,CAAC;GAEvD,IAAI,cAAc,SAAS,GAC1B,OAAO,aAAa,aAAa;EAEnC,CAAC;EAEF,iBAAiB,WAChB,OAAO,IAAI,aAAa;GACvB,gBAAgB;GAChB,OAAO,aAAa,MAAM;EAC3B,CAAC;EAEF,cAAc,QACb,OAAO,IAAI,aAAa;GACvB,MAAM,MAAM,OAAO,MAAM,SAAS;GAClC,MAAM,UAAyB,CAAC;GAChC,KAAK,MAAM,KAAK,KAAK;IACpB,MAAM,QAAQ,OAAO,EAAE,MAAM,GAAG;IAChC,IAAI,UAAU,gBAAgB,UAAU,mBACvC,QAAQ,KAAK,CAAC;GAEhB;GACA,OAAO;EACR,CAAC;EAEF,kBAAkB,QACjB,OAAO,IAAI,aAAa;GACvB,MAAM,MAAM,OAAO,MAAM,SAAS;GAClC,MAAM,UAAyB,CAAC;GAChC,KAAK,MAAM,KAAK,KAEf,KAAI,OADiB,EAAE,MAAM,GAAG,OAClB,WACb,QAAQ,KAAK,CAAC;GAGhB,OAAO;EACR,CAAC;CACH;AACD,CAAC,CACF"}

package/layers/NodeResolverLive.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"NodeResolverLive.js","names":[],"sources":["../../../../src/layers/NodeResolverLive.ts"],"sourcesContent":["import { DateTime, Effect, Layer } from \"effect\";\nimport { SemVer } from \"semver-effect\";\nimport { VersionNotFoundError } from \"../errors/VersionNotFoundError.js\";\nimport type { Increments, NodePhase } from \"../schemas/common.js\";\nimport type { NodeRelease } from \"../schemas/node-release.js\";\nimport { NodeReleaseCache } from \"../services/NodeReleaseCache.js\";\nimport type { NodeResolverOptions } from \"../services/NodeResolver.js\";\nimport { NodeResolver } from \"../services/NodeResolver.js\";\n\n/**\n * Provides the {@link NodeResolver} service backed by a {@link NodeReleaseCache}.\n *\n * This layer composes with any of the three Node cache strategy layers to form\n * a complete resolver stack. In addition to semver range filtering and increment\n * grouping, it supports filtering by Node.js release phase (e.g., `\"current\"`,\n * `\"active-lts\"`, `\"maintenance-lts\"`, `\"end-of-life\"`) and automatically\n * determines the current LTS version from the loaded schedule data.\n *\n * @example\n * ```ts\n * import {\n *   NodeResolverLive, AutoNodeCacheLive,\n *   NodeVersionFetcherLive, NodeScheduleFetcherLive,\n *   GitHubClientLive, GitHubAutoAuth,\n * } from \"runtime-resolver\";\n * import { NodeResolver } from \"runtime-resolver\";\n * import { Effect, Layer } from \"effect\";\n *\n * const GitHubLayer = GitHubClientLive.pipe(Layer.provide(GitHubAutoAuth));\n * const FetchersLayer = Layer.merge(\n *   NodeVersionFetcherLive.pipe(Layer.provide(GitHubLayer)),\n *   NodeScheduleFetcherLive.pipe(Layer.provide(GitHubLayer)),\n * );\n * const CacheLayer = AutoNodeCacheLive.pipe(Layer.provide(FetchersLayer));\n * const ResolverLayer = NodeResolverLive.pipe(Layer.provide(CacheLayer));\n *\n * const program = Effect.gen(function* () {\n *   const resolver = yield* NodeResolver;\n *   // Resolve only active-LTS and maintenance-LTS releases in the ^20 range\n *   const result = yield* resolver.resolve({\n *     semverRange: \"^20.0.0\",\n *     phases: [\"active-lts\", \"maintenance-lts\"],\n *   });\n *   console.log(result.lts);\n * });\n *\n * Effect.runPromise(program.pipe(Effect.provide(ResolverLayer)));\n * ```\n *\n * @see {@link NodeResolver}\n * @see {@link NodeReleaseCache}\n * @see {@link AutoNodeCacheLive}\n * @see {@link FreshNodeCacheLive}\n * @see {@link OfflineNodeCacheLive}\n * @public\n */\nexport const NodeResolverLive: Layer.Layer<NodeResolver, never, NodeReleaseCache> = Layer.effect(\n\tNodeResolver,\n\tEffect.gen(function* () {\n\t\tconst cache = yield* NodeReleaseCache;\n\n\t\treturn {\n\t\t\tresolve: (options?: NodeResolverOptions) =>\n\t\t\t\tEffect.gen(function* () {\n\t\t\t\t\tconst semverRange = options?.semverRange ?? \"*\";\n\t\t\t\t\tconst phases: ReadonlyArray<NodePhase> = options?.phases ?? [\"current\", \"active-lts\"];\n\t\t\t\t\tconst increments: Increments = options?.increments ?? \"latest\";\n\t\t\t\t\tconst now = options?.date ? DateTime.unsafeMake(options.date) : DateTime.unsafeMake(new Date());\n\n\t\t\t\t\t// Get all releases matching range\n\t\t\t\t\tconst matching = yield* cache\n\t\t\t\t\t\t.filter(semverRange)\n\t\t\t\t\t\t.pipe(Effect.catchAll(() => Effect.succeed([] as ReadonlyArray<NodeRelease>)));\n\n\t\t\t\t\t// Filter by phase\n\t\t\t\t\tconst phaseFiltered: NodeRelease[] = [];\n\t\t\t\t\tfor (const r of matching) {\n\t\t\t\t\t\tconst phase = yield* r.phase(now);\n\t\t\t\t\t\tif (phase && phases.includes(phase)) {\n\t\t\t\t\t\t\tphaseFiltered.push(r);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Apply increments\n\t\t\t\t\tlet resultReleases: NodeRelease[];\n\t\t\t\t\tif (increments === \"latest\") {\n\t\t\t\t\t\tconst groups = new Map<number, NodeRelease>();\n\t\t\t\t\t\tfor (const r of phaseFiltered) {\n\t\t\t\t\t\t\tconst existing = groups.get(r.version.major);\n\t\t\t\t\t\t\tif (!existing || SemVer.gt(r.version, existing.version)) {\n\t\t\t\t\t\t\t\tgroups.set(r.version.major, r);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tresultReleases = [...groups.values()];\n\t\t\t\t\t} else if (increments === \"minor\") {\n\t\t\t\t\t\tconst groups = new Map<string, NodeRelease>();\n\t\t\t\t\t\tfor (const r of phaseFiltered) {\n\t\t\t\t\t\t\tconst key = `${r.version.major}.${r.version.minor}`;\n\t\t\t\t\t\t\tconst existing = groups.get(key);\n\t\t\t\t\t\t\tif (!existing || SemVer.gt(r.version, existing.version)) {\n\t\t\t\t\t\t\t\tgroups.set(key, r);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tresultReleases = [...groups.values()];\n\t\t\t\t\t} else {\n\t\t\t\t\t\tresultReleases = phaseFiltered;\n\t\t\t\t\t}\n\n\t\t\t\t\tif (resultReleases.length === 0) {\n\t\t\t\t\t\treturn yield* Effect.fail(\n\t\t\t\t\t\t\tnew VersionNotFoundError({\n\t\t\t\t\t\t\t\truntime: \"node\",\n\t\t\t\t\t\t\t\tconstraint: semverRange,\n\t\t\t\t\t\t\t\tmessage: `No Node.js versions found matching \"${semverRange}\" with phases [${phases.join(\", \")}]`,\n\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\n\t\t\t\t\t// Sort descending\n\t\t\t\t\tconst sorted = SemVer.rsort(resultReleases.map((r) => r.version));\n\t\t\t\t\tconst sortedReleases = sorted\n\t\t\t\t\t\t.map((v) => resultReleases.find((r) => SemVer.equal(r.version, v)))\n\t\t\t\t\t\t.filter((r): r is NodeRelease => r !== undefined);\n\n\t\t\t\t\tconst versions = sortedReleases.map((r) => r.version.toString());\n\t\t\t\t\tconst latest = versions[0];\n\n\t\t\t\t\t// Determine LTS\n\t\t\t\t\tconst ltsReleases = yield* cache.ltsReleases(now);\n\t\t\t\t\tconst ltsVersions = ltsReleases.filter((r) => versions.includes(r.version.toString())).map((r) => r.version);\n\t\t\t\t\tconst lts = ltsVersions.length > 0 ? SemVer.rsort(ltsVersions)[0].toString() : undefined;\n\n\t\t\t\t\t// Handle default version\n\t\t\t\t\tlet resolvedDefault: string | undefined;\n\t\t\t\t\tif (options?.defaultVersion) {\n\t\t\t\t\t\tresolvedDefault = yield* cache.resolve(options.defaultVersion).pipe(\n\t\t\t\t\t\t\tEffect.map((r) => r.version.toString()),\n\t\t\t\t\t\t\tEffect.catchAll(() => Effect.succeed(undefined)),\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\n\t\t\t\t\treturn {\n\t\t\t\t\t\tsource: \"api\" as const,\n\t\t\t\t\t\tversions,\n\t\t\t\t\t\tlatest,\n\t\t\t\t\t\t...(lts ? { lts } : {}),\n\t\t\t\t\t\t...(resolvedDefault ? { default: resolvedDefault } : { ...(lts ? { default: lts } : {}) }),\n\t\t\t\t\t};\n\t\t\t\t}),\n\t\t};\n\t}),\n);\n"],"mappings":"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"}

package/layers/NodeScheduleFetcherLive.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"NodeScheduleFetcherLive.js","names":[],"sources":["../../../../src/layers/NodeScheduleFetcherLive.ts"],"sourcesContent":["import { Effect, Layer, Schema } from \"effect\";\nimport { ParseError } from \"../errors/ParseError.js\";\nimport { NodeReleaseSchedule } from \"../schemas/node.js\";\nimport type { NodeScheduleData } from \"../schemas/node-schedule.js\";\nimport { GitHubClient } from \"../services/GitHubClient.js\";\nimport { NodeScheduleFetcher } from \"../services/NodeScheduleFetcher.js\";\n\nconst NODE_SCHEDULE_URL = \"https://raw.githubusercontent.com/nodejs/Release/refs/heads/main/schedule.json\";\n\nconst decodeSchedule = (input: unknown): Effect.Effect<NodeScheduleData, ParseError> =>\n\tSchema.decodeUnknown(NodeReleaseSchedule)(input).pipe(\n\t\tEffect.mapError(\n\t\t\t(e) =>\n\t\t\t\tnew ParseError({\n\t\t\t\t\tsource: NODE_SCHEDULE_URL,\n\t\t\t\t\tmessage: `Schema validation failed: ${e.message}`,\n\t\t\t\t}),\n\t\t),\n\t\tEffect.map((data) => data as NodeScheduleData),\n\t);\n\n/**\n * Provides the {@link NodeScheduleFetcher} service using the live Node.js release schedule.\n *\n * Fetches the Node.js release schedule from the raw GitHub content URL for\n * `nodejs/Release` (`schedule.json` on the `main` branch) using the HTTP client\n * on the provided {@link GitHubClient} service. The schedule data maps major\n * version codenames to their start, LTS, and end-of-life dates and is used by\n * {@link NodeReleaseCache} to compute per-release lifecycle phases.\n *\n * This layer is a required dependency of {@link AutoNodeCacheLive} and\n * {@link FreshNodeCacheLive}. It is not needed by {@link OfflineNodeCacheLive}.\n *\n * @see {@link NodeScheduleFetcher}\n * @see {@link GitHubClient}\n * @see {@link AutoNodeCacheLive}\n * @see {@link FreshNodeCacheLive}\n * @public\n */\nexport const NodeScheduleFetcherLive: Layer.Layer<NodeScheduleFetcher, never, GitHubClient> = Layer.effect(\n\tNodeScheduleFetcher,\n\tEffect.gen(function* () {\n\t\tconst client = yield* GitHubClient;\n\t\treturn {\n\t\t\tfetch: () => client.getJson(NODE_SCHEDULE_URL, { decode: decodeSchedule }),\n\t\t};\n\t}),\n);\n"],"mappings":";;;;;;;AAOA,MAAM,oBAAoB;AAE1B,MAAM,kBAAkB,UACvB,OAAO,cAAc,mBAAmB,CAAC,CAAC,KAAK,CAAC,CAAC,KAChD,OAAO,UACL,MACA,IAAI,WAAW;CACd,QAAQ;CACR,SAAS,6BAA6B,EAAE;AACzC,CAAC,CACH,GACA,OAAO,KAAK,SAAS,IAAwB,CAC9C;;;;;;;;;;;;;;;;;;;AAoBD,MAAa,0BAAiF,MAAM,OACnG,qBACA,OAAO,IAAI,aAAa;CACvB,MAAM,SAAS,OAAO;CACtB,OAAO,EACN,aAAa,OAAO,QAAQ,mBAAmB,EAAE,QAAQ,eAAe,CAAC,EAC1E;AACD,CAAC,CACF"}

package/layers/NodeVersionFetcherLive.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"NodeVersionFetcherLive.js","names":[],"sources":["../../../../src/layers/NodeVersionFetcherLive.ts"],"sourcesContent":["import { Effect, Layer, Option, Schema } from \"effect\";\nimport { ParseError } from \"../errors/ParseError.js\";\nimport { tryParseSemVer } from \"../lib/semver.js\";\nimport { NodeDistIndex } from \"../schemas/node.js\";\nimport type { NodeReleaseInput } from \"../schemas/node-release.js\";\nimport { GitHubClient } from \"../services/GitHubClient.js\";\nimport { NodeVersionFetcher } from \"../services/NodeVersionFetcher.js\";\n\nconst NODE_DIST_URL = \"https://nodejs.org/dist/index.json\";\n\nconst decodeDistIndex = (input: unknown) =>\n\tSchema.decodeUnknown(NodeDistIndex)(input).pipe(\n\t\tEffect.mapError(\n\t\t\t(e) =>\n\t\t\t\tnew ParseError({\n\t\t\t\t\tsource: NODE_DIST_URL,\n\t\t\t\t\tmessage: `Schema validation failed: ${e.message}`,\n\t\t\t\t}),\n\t\t),\n\t);\n\n/**\n * Provides the {@link NodeVersionFetcher} service using the live Node.js dist index.\n *\n * Fetches the full Node.js version list from `https://nodejs.org/dist/index.json`\n * using the HTTP client on the provided {@link GitHubClient} service. Version\n * strings are normalized by stripping the leading `v` before parsing as semver.\n * Entries with non-string `npm` fields (present in very old releases prior to\n * v0.6.3) are substituted with the sentinel version `\"0.0.0\"`.\n *\n * This layer is a required dependency of {@link AutoNodeCacheLive} and\n * {@link FreshNodeCacheLive}. It is not needed by {@link OfflineNodeCacheLive}.\n *\n * @see {@link NodeVersionFetcher}\n * @see {@link GitHubClient}\n * @see {@link AutoNodeCacheLive}\n * @see {@link FreshNodeCacheLive}\n * @public\n */\nexport const NodeVersionFetcherLive: Layer.Layer<NodeVersionFetcher, never, GitHubClient> = Layer.effect(\n\tNodeVersionFetcher,\n\tEffect.gen(function* () {\n\t\tconst client = yield* GitHubClient;\n\n\t\treturn {\n\t\t\tfetch: () =>\n\t\t\t\tEffect.gen(function* () {\n\t\t\t\t\tconst allVersions = yield* client.getJson(NODE_DIST_URL, {\n\t\t\t\t\t\tdecode: decodeDistIndex,\n\t\t\t\t\t});\n\n\t\t\t\t\tconst parsed = yield* Effect.forEach(\n\t\t\t\t\t\tallVersions,\n\t\t\t\t\t\t(entry) => {\n\t\t\t\t\t\t\tconst clean = entry.version.replace(/^v/, \"\");\n\t\t\t\t\t\t\treturn tryParseSemVer(clean).pipe(\n\t\t\t\t\t\t\t\tEffect.map((opt) =>\n\t\t\t\t\t\t\t\t\tOption.isSome(opt)\n\t\t\t\t\t\t\t\t\t\t? Option.some({\n\t\t\t\t\t\t\t\t\t\t\t\tversion: opt.value,\n\t\t\t\t\t\t\t\t\t\t\t\tinput: {\n\t\t\t\t\t\t\t\t\t\t\t\t\tversion: clean,\n\t\t\t\t\t\t\t\t\t\t\t\t\t// Older entries (pre-v0.6.3) carry npm:false. Use \"0.0.0\" as a sentinel\n\t\t\t\t\t\t\t\t\t\t\t\t\t// since npm version is only informational and never used in comparisons.\n\t\t\t\t\t\t\t\t\t\t\t\t\tnpm: typeof entry.npm === \"string\" ? entry.npm : \"0.0.0\",\n\t\t\t\t\t\t\t\t\t\t\t\t\tdate: entry.date,\n\t\t\t\t\t\t\t\t\t\t\t\t} satisfies NodeReleaseInput,\n\t\t\t\t\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t\t\t\t: Option.none(),\n\t\t\t\t\t\t\t\t),\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t},\n\t\t\t\t\t\t{ concurrency: \"unbounded\" },\n\t\t\t\t\t);\n\n\t\t\t\t\tconst versions = parsed.flatMap(Option.toArray).map(({ version }) => version);\n\t\t\t\t\tconst inputs = parsed.flatMap(Option.toArray).map(({ input }) => input);\n\n\t\t\t\t\treturn { versions, inputs };\n\t\t\t\t}),\n\t\t};\n\t}),\n);\n"],"mappings":";;;;;;;;AAQA,MAAM,gBAAgB;AAEtB,MAAM,mBAAmB,UACxB,OAAO,cAAc,aAAa,CAAC,CAAC,KAAK,CAAC,CAAC,KAC1C,OAAO,UACL,MACA,IAAI,WAAW;CACd,QAAQ;CACR,SAAS,6BAA6B,EAAE;AACzC,CAAC,CACH,CACD;;;;;;;;;;;;;;;;;;;AAoBD,MAAa,yBAA+E,MAAM,OACjG,oBACA,OAAO,IAAI,aAAa;CACvB,MAAM,SAAS,OAAO;CAEtB,OAAO,EACN,aACC,OAAO,IAAI,aAAa;EACvB,MAAM,cAAc,OAAO,OAAO,QAAQ,eAAe,EACxD,QAAQ,gBACT,CAAC;EAED,MAAM,SAAS,OAAO,OAAO,QAC5B,cACC,UAAU;GACV,MAAM,QAAQ,MAAM,QAAQ,QAAQ,MAAM,EAAE;GAC5C,OAAO,eAAe,KAAK,CAAC,CAAC,KAC5B,OAAO,KAAK,QACX,OAAO,OAAO,GAAG,IACd,OAAO,KAAK;IACZ,SAAS,IAAI;IACb,OAAO;KACN,SAAS;KAGT,KAAK,OAAO,MAAM,QAAQ,WAAW,MAAM,MAAM;KACjD,MAAM,MAAM;IACb;GACD,CAAC,IACA,OAAO,KAAK,CAChB,CACD;EACD,GACA,EAAE,aAAa,YAAY,CAC5B;EAKA,OAAO;GAAE,UAHQ,OAAO,QAAQ,OAAO,OAAO,CAAC,CAAC,KAAK,EAAE,cAAc,OAGrD;GAAG,QAFJ,OAAO,QAAQ,OAAO,OAAO,CAAC,CAAC,KAAK,EAAE,YAAY,KAEzC;EAAE;CAC3B,CAAC,EACH;AACD,CAAC,CACF"}

package/layers/OfflineBunCacheLive.js.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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/schemas/bun-release.js.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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"}

package/schemas/github.js.map

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

package/schemas/node-release.js.map

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

package/schemas/node-schedule.js.map

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

package/schemas/node.js.map

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

package/services/BunReleaseCache.js.map

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

package/services/BunResolver.js.map

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

package/services/BunVersionFetcher.js.map

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

package/services/DenoReleaseCache.js.map

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

package/services/DenoResolver.js.map

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

package/services/DenoVersionFetcher.js.map

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

package/services/GitHubClient.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"GitHubClient.js","names":[],"sources":["../../../../src/services/GitHubClient.ts"],"sourcesContent":["import type { Effect } from \"effect\";\nimport { Context } from \"effect\";\nimport type { AuthenticationError } from \"../errors/AuthenticationError.js\";\nimport type { NetworkError } from \"../errors/NetworkError.js\";\nimport type { ParseError } from \"../errors/ParseError.js\";\nimport type { RateLimitError } from \"../errors/RateLimitError.js\";\nimport type { GitHubRelease, GitHubTag } from \"../schemas/github.js\";\n\n/**\n * Pagination options shared by all list operations on {@link GitHubClient}.\n *\n * @see {@link GitHubClient}\n *\n * @public\n */\nexport interface ListOptions {\n\t/**\n\t * Number of items to request per page. Defaults to the GitHub API maximum\n\t * of `100` when omitted.\n\t */\n\treadonly perPage?: number;\n\n\t/**\n\t * Maximum number of pages to fetch. When omitted all pages are fetched\n\t * until the API returns an empty result set.\n\t */\n\treadonly pages?: number;\n}\n\n/**\n * Service for GitHub REST API operations used by the version\n * fetcher services.\n *\n * Abstracts over pagination and authentication so that higher-level services\n * such as {@link BunVersionFetcher}, {@link DenoVersionFetcher}, and\n * {@link NodeScheduleFetcher} remain independent of the underlying HTTP\n * transport. The live implementation is provided by {@link GitHubClientLive}\n * and requires an {@link OctokitInstance} in its dependency graph.\n *\n * @example\n * ```typescript\n * import type { GitHubTag } from \"runtime-resolver\";\n * import { GitHubClient, GitHubClientLive, GitHubAutoAuth } from \"runtime-resolver\";\n * import { Effect } from \"effect\";\n *\n * const program = Effect.gen(function* () {\n * \tconst client = yield* GitHubClient;\n * \tconst tags = yield* client.listTags(\"oven-sh\", \"bun\", { perPage: 100 });\n * \tconsole.log(`Found ${tags.length} tags`);\n * });\n *\n * Effect.runPromise(\n * \tprogram.pipe(Effect.provide(GitHubClientLive), Effect.provide(GitHubAutoAuth)),\n * );\n * ```\n *\n * @see {@link GitHubClientLive}\n * @see {@link OctokitInstance}\n * @see {@link ListOptions}\n *\n * @public\n */\nexport class GitHubClient extends Context.Tag(\"runtime-resolver/GitHubClient\")<\n\tGitHubClient,\n\t{\n\t\t/**\n\t\t * Lists all git tags for the given repository, automatically paginating\n\t\t * through results according to `options`.\n\t\t *\n\t\t * Fails with:\n\t\t * - {@link AuthenticationError} — missing or invalid GitHub credentials.\n\t\t * - {@link NetworkError} — the upstream request could not be completed.\n\t\t * - {@link RateLimitError} — the GitHub API rate limit was exceeded.\n\t\t * - {@link ParseError} — a response page could not be decoded.\n\t\t *\n\t\t * @param owner - GitHub organisation or user name (e.g. `\"oven-sh\"`).\n\t\t * @param repo - Repository name (e.g. `\"bun\"`).\n\t\t * @param options - Optional pagination controls.\n\t\t */\n\t\treadonly listTags: (\n\t\t\towner: string,\n\t\t\trepo: string,\n\t\t\toptions?: ListOptions,\n\t\t) => Effect.Effect<ReadonlyArray<GitHubTag>, AuthenticationError | NetworkError | RateLimitError | ParseError>;\n\n\t\t/**\n\t\t * Lists all GitHub Releases for the given repository, automatically\n\t\t * paginating through results according to `options`.\n\t\t *\n\t\t * Fails with:\n\t\t * - {@link AuthenticationError} — missing or invalid GitHub credentials.\n\t\t * - {@link NetworkError} — the upstream request could not be completed.\n\t\t * - {@link RateLimitError} — the GitHub API rate limit was exceeded.\n\t\t * - {@link ParseError} — a response page could not be decoded.\n\t\t *\n\t\t * @param owner - GitHub organisation or user name (e.g. `\"denoland\"`).\n\t\t * @param repo - Repository name (e.g. `\"deno\"`).\n\t\t * @param options - Optional pagination controls.\n\t\t */\n\t\treadonly listReleases: (\n\t\t\towner: string,\n\t\t\trepo: string,\n\t\t\toptions?: ListOptions,\n\t\t) => Effect.Effect<ReadonlyArray<GitHubRelease>, AuthenticationError | NetworkError | RateLimitError | ParseError>;\n\n\t\t/**\n\t\t * Fetches arbitrary JSON from `url` and decodes it with the provided\n\t\t * schema, returning the typed result.\n\t\t *\n\t\t * Useful for endpoints outside the standard Octokit REST methods (e.g.\n\t\t * raw GitHub content URLs).\n\t\t *\n\t\t * Fails with:\n\t\t * - {@link NetworkError} — the upstream request could not be completed.\n\t\t * - {@link ParseError} — the response body could not be decoded by `schema`.\n\t\t *\n\t\t * @typeParam A - The decoded output type produced by `schema`.\n\t\t * @param url - Fully qualified URL to fetch.\n\t\t * @param schema - An object with a `decode` method compatible with\n\t\t * Effect Schema's `decodeUnknown`.\n\t\t */\n\t\treadonly getJson: <A>(\n\t\t\turl: string,\n\t\t\tschema: {\n\t\t\t\treadonly decode: (input: unknown) => Effect.Effect<A, ParseError>;\n\t\t\t},\n\t\t) => Effect.Effect<A, NetworkError | ParseError>;\n\t}\n>() {}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8DA,IAAa,eAAb,cAAkC,QAAQ,IAAI,+BAA+B,CAAC,CAkE5E,CAAC,CAAC,CAAC"}