runtime-resolver 0.1.0 → 0.3.0

package/index.js

@@ -1,9 +1,129 @@
-import { Layer, NodeResolver, GitHubAutoAuth, BunResolverLive, DenoResolverLive, GitHubClientLive, VersionCacheLive, Effect, BunResolver, DenoResolver, NodeResolverLive } from "./969.js";
+import { Data, Effect, Layer } from "effect";
+import { SemVerParserLive, VersionCacheLive } from "semver-effect";
+import { DenoReleaseCacheLive, BunRelease, AutoDenoCacheLive, NodeReleaseCacheLive, NodeReleaseCache, AutoNodeCacheLive, denoDefaultInputs, BunReleaseCache, nodeDefaultInputs, NodeResolverLive, BunVersionFetcherLive, DenoResolverLive, GitHubClientLive, BunVersionFetcher, NodeScheduleFetcher, DenoResolver, NodeScheduleFetcherLive, DenoVersionFetcherLive, NodeVersionFetcher, DenoReleaseCache, BunReleaseCacheLive, BunResolver, DenoRelease, bunDefaultInputs, NodeVersionFetcherLive, GitHubAutoAuth, BunResolverLive, NodeResolver, AutoBunCacheLive, DenoVersionFetcher, nodeDefaultScheduleData } from "./711.js";
+class CacheError extends Data.TaggedError("CacheError") {
+}
+class FreshnessError extends Data.TaggedError("FreshnessError") {
+}
+class InvalidInputError extends Data.TaggedError("InvalidInputError") {
+}
+const freshSetup = Effect.gen(function*() {
+    const cache = yield* BunReleaseCache;
+    const fetcher = yield* BunVersionFetcher;
+    const { inputs } = yield* fetcher.fetch().pipe(Effect.catchTags({
+        AuthenticationError: (err)=>Effect.fail(new FreshnessError({
+                strategy: "api",
+                message: `Fresh data required but authentication failed: ${err.message}`
+            })),
+        NetworkError: (err)=>Effect.fail(new FreshnessError({
+                strategy: "api",
+                message: `Fresh data required but network unavailable: ${err.message}`
+            })),
+        ParseError: (err)=>Effect.fail(new FreshnessError({
+                strategy: "api",
+                message: `Fresh data required but parse failed: ${err.message}`
+            })),
+        RateLimitError: (err)=>Effect.fail(new FreshnessError({
+                strategy: "api",
+                message: `Fresh data required but rate limit exceeded: ${err.message}`
+            }))
+    }));
+    const releases = yield* Effect.all(inputs.map((input)=>BunRelease.fromInput(input)), {
+        concurrency: "unbounded"
+    }).pipe(Effect.orElseSucceed(()=>[]));
+    yield* cache.load(releases);
+});
+const SemVerLayer = VersionCacheLive.pipe(Layer.provide(SemVerParserLive));
+const BaseCacheLayer = BunReleaseCacheLive.pipe(Layer.provide(SemVerLayer));
+const FreshBunCacheLive = BaseCacheLayer.pipe(Layer.tap((ctx)=>freshSetup.pipe(Effect.provide(ctx))));
+const FreshDenoCacheLive_freshSetup = Effect.gen(function*() {
+    const cache = yield* DenoReleaseCache;
+    const fetcher = yield* DenoVersionFetcher;
+    const { inputs } = yield* fetcher.fetch().pipe(Effect.catchTags({
+        AuthenticationError: (err)=>Effect.fail(new FreshnessError({
+                strategy: "api",
+                message: `Fresh data required but authentication failed: ${err.message}`
+            })),
+        NetworkError: (err)=>Effect.fail(new FreshnessError({
+                strategy: "api",
+                message: `Fresh data required but network unavailable: ${err.message}`
+            })),
+        ParseError: (err)=>Effect.fail(new FreshnessError({
+                strategy: "api",
+                message: `Fresh data required but parse failed: ${err.message}`
+            })),
+        RateLimitError: (err)=>Effect.fail(new FreshnessError({
+                strategy: "api",
+                message: `Fresh data required but rate limit exceeded: ${err.message}`
+            }))
+    }));
+    const releases = yield* Effect.all(inputs.map((input)=>DenoRelease.fromInput(input)), {
+        concurrency: "unbounded"
+    }).pipe(Effect.orElseSucceed(()=>[]));
+    yield* cache.load(releases);
+});
+const FreshDenoCacheLive_SemVerLayer = VersionCacheLive.pipe(Layer.provide(SemVerParserLive));
+const FreshDenoCacheLive_BaseCacheLayer = DenoReleaseCacheLive.pipe(Layer.provide(FreshDenoCacheLive_SemVerLayer));
+const FreshDenoCacheLive = FreshDenoCacheLive_BaseCacheLayer.pipe(Layer.tap((ctx)=>FreshDenoCacheLive_freshSetup.pipe(Effect.provide(ctx))));
+const FreshNodeCacheLive_freshSetup = Effect.gen(function*() {
+    const cache = yield* NodeReleaseCache;
+    const versionFetcher = yield* NodeVersionFetcher;
+    const scheduleFetcher = yield* NodeScheduleFetcher;
+    const [fetchResult, scheduleData] = yield* Effect.all([
+        versionFetcher.fetch(),
+        scheduleFetcher.fetch()
+    ]).pipe(Effect.catchTags({
+        NetworkError: (err)=>Effect.fail(new FreshnessError({
+                strategy: "api",
+                message: `Fresh data required but network unavailable: ${err.message}`
+            })),
+        ParseError: (err)=>Effect.fail(new FreshnessError({
+                strategy: "api",
+                message: `Fresh data required but response could not be parsed: ${err.message}`
+            }))
+    }));
+    yield* cache.updateSchedule(scheduleData);
+    yield* cache.loadFromInputs(fetchResult.inputs);
+});
+const FreshNodeCacheLive_SemVerLayer = VersionCacheLive.pipe(Layer.provide(SemVerParserLive));
+const FreshNodeCacheLive_BaseCacheLayer = NodeReleaseCacheLive.pipe(Layer.provide(FreshNodeCacheLive_SemVerLayer));
+const FreshNodeCacheLive = FreshNodeCacheLive_BaseCacheLayer.pipe(Layer.tap((ctx)=>FreshNodeCacheLive_freshSetup.pipe(Effect.provide(ctx))));
+const offlineSetup = Effect.gen(function*() {
+    const cache = yield* BunReleaseCache;
+    const releases = yield* Effect.all(bunDefaultInputs.map((input)=>BunRelease.fromInput(input)), {
+        concurrency: "unbounded"
+    }).pipe(Effect.orElseSucceed(()=>[]));
+    yield* cache.load(releases);
+});
+const OfflineBunCacheLive_SemVerLayer = VersionCacheLive.pipe(Layer.provide(SemVerParserLive));
+const OfflineBunCacheLive_BaseCacheLayer = BunReleaseCacheLive.pipe(Layer.provide(OfflineBunCacheLive_SemVerLayer));
+const OfflineBunCacheLive = OfflineBunCacheLive_BaseCacheLayer.pipe(Layer.tap((ctx)=>offlineSetup.pipe(Effect.provide(ctx))));
+const OfflineDenoCacheLive_offlineSetup = Effect.gen(function*() {
+    const cache = yield* DenoReleaseCache;
+    const releases = yield* Effect.all(denoDefaultInputs.map((input)=>DenoRelease.fromInput(input)), {
+        concurrency: "unbounded"
+    }).pipe(Effect.orElseSucceed(()=>[]));
+    yield* cache.load(releases);
+});
+const OfflineDenoCacheLive_SemVerLayer = VersionCacheLive.pipe(Layer.provide(SemVerParserLive));
+const OfflineDenoCacheLive_BaseCacheLayer = DenoReleaseCacheLive.pipe(Layer.provide(OfflineDenoCacheLive_SemVerLayer));
+const OfflineDenoCacheLive = OfflineDenoCacheLive_BaseCacheLayer.pipe(Layer.tap((ctx)=>OfflineDenoCacheLive_offlineSetup.pipe(Effect.provide(ctx))));
+const OfflineNodeCacheLive_offlineSetup = Effect.gen(function*() {
+    const cache = yield* NodeReleaseCache;
+    yield* cache.updateSchedule(nodeDefaultScheduleData);
+    yield* cache.loadFromInputs(nodeDefaultInputs);
+});
+const OfflineNodeCacheLive_SemVerLayer = VersionCacheLive.pipe(Layer.provide(SemVerParserLive));
+const OfflineNodeCacheLive_BaseCacheLayer = NodeReleaseCacheLive.pipe(Layer.provide(OfflineNodeCacheLive_SemVerLayer));
+const OfflineNodeCacheLive = OfflineNodeCacheLive_BaseCacheLayer.pipe(Layer.tap((ctx)=>OfflineNodeCacheLive_offlineSetup.pipe(Effect.provide(ctx))));
 const GitHubLayer = GitHubClientLive.pipe(Layer.provide(GitHubAutoAuth));
-const SharedLayer = Layer.merge(GitHubLayer, VersionCacheLive);
-const NodeLayer = NodeResolverLive.pipe(Layer.provide(SharedLayer));
-const BunLayer = BunResolverLive.pipe(Layer.provide(SharedLayer));
-const DenoLayer = DenoResolverLive.pipe(Layer.provide(SharedLayer));
+const NodeFetchersLayer = Layer.merge(NodeVersionFetcherLive.pipe(Layer.provide(GitHubLayer)), NodeScheduleFetcherLive.pipe(Layer.provide(GitHubLayer)));
+const NodeCacheLayer = AutoNodeCacheLive.pipe(Layer.provide(NodeFetchersLayer));
+const NodeLayer = NodeResolverLive.pipe(Layer.provide(NodeCacheLayer));
+const BunCacheLayer = AutoBunCacheLive.pipe(Layer.provide(BunVersionFetcherLive.pipe(Layer.provide(GitHubLayer))));
+const BunLayer = BunResolverLive.pipe(Layer.provide(BunCacheLayer));
+const DenoCacheLayer = AutoDenoCacheLive.pipe(Layer.provide(DenoVersionFetcherLive.pipe(Layer.provide(GitHubLayer))));
+const DenoLayer = DenoResolverLive.pipe(Layer.provide(DenoCacheLayer));
 const resolveNode = (options)=>Effect.runPromise(Effect.gen(function*() {
         const resolver = yield* NodeResolver;
         return yield* resolver.resolve(options);
@@ -16,5 +136,5 @@ const resolveDeno = (options)=>Effect.runPromise(Effect.gen(function*() {
         const resolver = yield* DenoResolver;
         return yield* resolver.resolve(options);
     }).pipe(Effect.provide(DenoLayer)));
-export { AuthenticationError, AuthenticationErrorBase, BunResolver, BunResolverLive, CacheError, CacheErrorBase, DenoResolver, DenoResolverLive, FreshnessError, FreshnessErrorBase, GitHubAppAuth, GitHubAutoAuth, GitHubClient, GitHubClientLive, GitHubTokenAuth, GitHubTokenAuthFromToken, InvalidInputError, InvalidInputErrorBase, NetworkError, NetworkErrorBase, NodeResolver, NodeResolverLive, OctokitInstance, ParseError, ParseErrorBase, RateLimitError, RateLimitErrorBase, VersionCache, VersionCacheLive, VersionNotFoundError, VersionNotFoundErrorBase } from "./969.js";
-export { resolveBun, resolveDeno, resolveNode };
+export { AuthenticationError, AutoBunCacheLive, AutoDenoCacheLive, AutoNodeCacheLive, BunRelease, BunReleaseCache, BunReleaseCacheLive, BunResolver, BunResolverLive, BunVersionFetcher, BunVersionFetcherLive, DenoRelease, DenoReleaseCache, DenoReleaseCacheLive, DenoResolver, DenoResolverLive, DenoVersionFetcher, DenoVersionFetcherLive, GitHubAppAuth, GitHubAutoAuth, GitHubClient, GitHubClientLive, GitHubTokenAuth, GitHubTokenAuthFromToken, NetworkError, NodeRelease, NodeReleaseCache, NodeReleaseCacheLive, NodeResolver, NodeResolverLive, NodeSchedule, NodeScheduleFetcher, NodeScheduleFetcherLive, NodeVersionFetcher, NodeVersionFetcherLive, OctokitInstance, ParseError, RateLimitError, VersionNotFoundError, createRuntimeCache } from "./711.js";
+export { CacheError, FreshBunCacheLive, FreshDenoCacheLive, FreshNodeCacheLive, FreshnessError, InvalidInputError, OfflineBunCacheLive, OfflineDenoCacheLive, OfflineNodeCacheLive, resolveBun, resolveDeno, resolveNode };

package/{235.js → json-schema.js}

@@ -1,4 +1,10 @@
-import { JSONSchema, Schema } from "./969.js";
+import { __webpack_require__ } from "./rslib-runtime.js";
+import { JSONSchema, Schema } from "effect";
+var json_schema_namespaceObject = {};
+__webpack_require__.r(json_schema_namespaceObject);
+__webpack_require__.d(json_schema_namespaceObject, {
+    cliJsonSchema: ()=>cliJsonSchema
+});
 const CliErrorDetail = Schema.Struct({
     _tag: Schema.String.annotations({
         description: "Error type identifier (e.g. RateLimitError, SemverError)"
@@ -86,4 +92,4 @@ const CliResponse = Schema.Union(CliSuccessResponse, CliErrorResponse).annotatio
     description: "CLI response envelope. Contains an ok discriminator and a results map with per-runtime resolution outcomes."
 });
 const cliJsonSchema = JSONSchema.make(CliResponse);
-export { cliJsonSchema };
+export { json_schema_namespaceObject };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runtime-resolver",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "private": false,
   "description": "Resolve semver-compatible versions of Node.js, Bun, and Deno runtimes with Effect-based architecture and offline fallback.",
   "keywords": [
@@ -30,6 +30,7 @@
     "email": "spencer@beggs.codes",
     "url": "https://spencerbeg.gs"
   },
+  "sideEffects": false,
   "type": "module",
   "exports": {
     ".": {
@@ -41,26 +42,27 @@
     "runtime-resolver": "./bin/runtime-resolver.js"
   },
   "dependencies": {
-    "@effect/cli": "^0.73.2",
-    "@effect/platform": "^0.94.5",
-    "@effect/platform-node": "^0.104.1",
+    "@effect/cli": "^0.74.0",
+    "@effect/platform": "^0.95.0",
+    "@effect/platform-node": "^0.105.0",
     "@octokit/auth-app": "^8.2.0",
-    "effect": "^3.19.19",
+    "effect": "^3.20.0",
     "octokit": "^5.0.5",
-    "semver": "^7.7.4"
+    "semver-effect": "^0.2.0"
   },
   "files": [
     "!runtime-resolver.api.json",
     "!tsconfig.json",
     "!tsdoc.json",
-    "235.js",
-    "969.js",
+    "711.js",
     "LICENSE",
     "README.md",
     "bin/runtime-resolver.js",
     "index.d.ts",
     "index.js",
+    "json-schema.js",
     "package.json",
+    "rslib-runtime.js",
     "tsdoc-metadata.json"
   ]
 }

package/rslib-runtime.js

@@ -0,0 +1,37 @@
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.d = (exports, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.add = function(modules) {
+        Object.assign(__webpack_require__.m, modules);
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports, '__esModule', {
+            value: true
+        });
+    };
+})();
+export { __webpack_require__ };

package/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.57.6"
+      "packageVersion": "7.57.7"
     }
   ]
 }