@dual-os/github-api 6.0.3 → 6.0.5

package/Runner.js

@@ -1,7 +1,6 @@
 // @bun
 import {
   pipeArguments,
-  dual,
   identity,
   constVoid,
   pipe,
@@ -11,26 +10,21 @@ import {
   isNotNull,
   isNullish,
   hasProperty,
-  hash,
-  equals,
   byReferenceUnsafe,
   format,
   NodeInspectSymbol,
   toJson,
   BaseProto,
-  PipeInspectableProto,
   Prototype,
   String2,
   mapInput,
   none,
   some,
-  isSome,
   match2,
   getOrElse,
   orElse,
   fromNullishOr,
   fromUndefinedOr,
-  getOrUndefined,
   map,
   flatMap,
   Service,
@@ -42,49 +36,44 @@ import {
   succeed,
   fail,
   getOrThrow,
-  empty,
   sort,
   of,
-  every,
   fromInputUnsafe,
   isFinite,
   toMillis,
-  toPredicate,
-  has2,
-  compose,
   Error2,
   TaggedError,
-  forkUnsafe,
-  isInterruptReason,
+  scopeRemoveFinalizerUnsafe,
+  fiberEnterUninterruptibleUnsafe,
   fail2,
-  hasInterruptsOnly,
   squash,
   hasInterrupts,
-  filterInterruptors,
   Done,
   done,
   UnknownError,
-  succeed2,
+  succeed3,
   fail3,
-  void_,
+  void_2,
   isSuccess2,
   isFailure,
   makeUnsafe2,
-  make,
   _await,
+  done2,
   fail4,
   isDone,
   isDoneUnsafe,
   doneUnsafe,
-  into,
   Scope,
+  make,
   makeUnsafe3,
   addFinalizerExit,
   addFinalizer,
-  fork,
+  forkUnsafe2,
   close,
+  makeMemoMapUnsafe,
+  buildWithMemoMap,
   buildWithScope,
-  succeed3,
+  succeed4,
   effect,
   mergeAll,
   provide,
@@ -96,10 +85,10 @@ import {
   all2,
   forEach,
   tryPromise,
-  succeed4,
+  succeed5,
   suspend,
-  sync,
-  void_2,
+  sync2,
+  void_3,
   undefined_,
   callback,
   never,
@@ -109,8 +98,9 @@ import {
   failCause,
   die,
   try_2,
-  withFiber,
+  withFiber2,
   flatMap3,
+  flatten2,
   andThen,
   tap,
   map4,
@@ -119,21 +109,19 @@ import {
   catch_,
   catchTag,
   catchReason,
-  catchCause,
   catchIf,
   catchCauseIf,
   mapError2,
   orDie,
-  tapCause,
   ignore,
   ignoreCause,
   sleep,
   raceFirst,
   matchEffect,
   context,
-  provide2,
   provideContext,
   serviceOption,
+  provideService,
   scope,
   scoped,
   acquireRelease,
@@ -151,14 +139,22 @@ import {
   forkScoped,
   runFork,
   runForkWith,
+  runCallbackWith,
+  runCallback,
+  runPromise,
+  runPromiseWith,
+  runPromiseExit,
+  runPromiseExitWith,
+  runSync,
+  runSyncWith,
+  runSyncExit,
+  runSyncExitWith,
   fnUntraced,
   clockWith,
-  logError,
   effectify,
   await_,
   join2,
   interrupt2,
-  interruptAll,
   getCurrent,
   runIn,
   make2,
@@ -178,8 +174,8 @@ import {
   encodeEffect,
   Unknown,
   String3,
+  Struct,
   Record,
-  Tuple,
   Literals,
   tag,
   NonEmptyString,
@@ -196,19 +192,18 @@ import {
   fromChannel,
   fromPull,
   callback2,
-  empty5,
+  empty4,
   suspend2,
   fail6,
   unwrap2,
   drainFork,
-  merge,
+  merge2,
   tapError,
   transduce,
   decodeText,
   splitLines,
   run,
   runCollect,
-  runForEach,
   runDrain,
   mkString,
   layer,
@@ -224,16 +219,13 @@ import {
   oauth2TokenRefresherLayer,
   make6,
   isPlugin,
-  Identity,
   filesUnavailable,
   PluginExecutionError,
-  ipcMessages,
-  sendIpc,
   decodeInput,
   encodeOutput,
   responseLimit,
   execute3
-} from "./plugin-gajxsj3f.js";
+} from "./plugin-w0va8331.js";
 var __defProp = Object.defineProperty;
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
@@ -249,111 +241,6 @@ var __export = (target, all) => {
     });
 };
 
-// ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/MutableHashMap.js
-var TypeId = "~effect/MutableHashMap";
-var MutableHashMapProto = {
-  [TypeId]: TypeId,
-  [Symbol.iterator]() {
-    return this.backing[Symbol.iterator]();
-  },
-  toString() {
-    return `MutableHashMap(${format(Array.from(this))})`;
-  },
-  toJSON() {
-    return {
-      _id: "MutableHashMap",
-      values: toJson(Array.from(this))
-    };
-  },
-  [NodeInspectSymbol]() {
-    return this.toJSON();
-  },
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-};
-var empty2 = () => {
-  const self = Object.create(MutableHashMapProto);
-  self.backing = new Map;
-  self.buckets = new Map;
-  return self;
-};
-var get2 = /* @__PURE__ */ dual(2, (self, key) => {
-  if (self.backing.has(key)) {
-    return some(self.backing.get(key));
-  } else if (isSimpleKey(key)) {
-    return none();
-  }
-  const hash2 = hash(key);
-  const bucket = self.buckets.get(hash2);
-  if (bucket === undefined) {
-    return none();
-  }
-  return getFromBucket(self, bucket, key);
-});
-var isSimpleKey = (u) => typeof u !== "object" && typeof u !== "function";
-var getFromBucket = (self, bucket, key) => {
-  for (let i = 0, len = bucket.length;i < len; i++) {
-    if (equals(key, bucket[i])) {
-      const refKey = bucket[i];
-      return some(self.backing.get(refKey));
-    }
-  }
-  return none();
-};
-var has = /* @__PURE__ */ dual(2, (self, key) => isSome(get2(self, key)));
-var set = /* @__PURE__ */ dual(3, (self, key, value) => {
-  if (self.backing.has(key) || isSimpleKey(key)) {
-    self.backing.set(key, value);
-    return self;
-  }
-  const hash2 = hash(key);
-  const bucket = self.buckets.get(hash2);
-  if (bucket === undefined) {
-    self.buckets.set(hash2, [key]);
-    self.backing.set(key, value);
-    return self;
-  }
-  let refKey = getRefKey(bucket, key);
-  if (refKey === undefined) {
-    bucket.push(key);
-    refKey = key;
-  }
-  self.backing.set(refKey, value);
-  return self;
-});
-var getRefKey = (bucket, key) => {
-  for (let i = 0, len = bucket.length;i < len; i++) {
-    if (equals(key, bucket[i])) {
-      return bucket[i];
-    }
-  }
-};
-var remove = /* @__PURE__ */ dual(2, (self, key_) => {
-  if (isSimpleKey(key_)) {
-    self.backing.delete(key_);
-    return self;
-  }
-  const hash2 = hash(key_);
-  const bucket = self.buckets.get(hash2);
-  if (bucket === undefined) {
-    return self;
-  }
-  for (let i = 0, len = bucket.length;i < len; i++) {
-    const bkey = bucket[i];
-    if (bkey === key_ || equals(key_, bkey)) {
-      self.backing.delete(bkey);
-      bucket.splice(i, 1);
-      break;
-    }
-  }
-  if (bucket.length === 0) {
-    self.buckets.delete(hash2);
-  }
-  return self;
-});
-var size = (self) => self.backing.size;
-
 // ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/internal/ulid.js
 var maxTimestamp = 2 ** 48 - 1;
 var base32Chars = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
@@ -524,9 +411,9 @@ var make3 = (randomBytes) => {
   const ulid = makeMonotonic();
   const ulidRandomBytes = () => randomBytes(10);
   return {
-    randomBytes: (size) => sync(() => randomBytesChecked(size)),
-    intBetween: (min, max, options) => sync(() => intBetweenUnsafe(min, max, options?.halfOpen ?? false, draw)),
-    shuffle: (elements) => sync(() => {
+    randomBytes: (size) => sync2(() => randomBytesChecked(size)),
+    intBetween: (min, max, options) => sync2(() => intBetweenUnsafe(min, max, options?.halfOpen ?? false, draw)),
+    shuffle: (elements) => sync2(() => {
       const buffer = Array.from(elements);
       for (let i = buffer.length - 1;i >= 1; i--) {
         const index = intBetweenUnsafe(0, i, false, draw);
@@ -536,9 +423,9 @@ var make3 = (randomBytes) => {
       }
       return buffer;
     }),
-    uuidV4: (options) => sync(() => makeUuid(v4Bytes, randomBytes, options?.format)),
-    uuidV7: (options) => clockWith((clock) => sync(() => makeUuid((bytes) => uuidV7(clock.currentTimeMillisUnsafe(), bytes), randomBytes, options?.format))),
-    ulid: clockWith((clock) => sync(() => ulid(clock.currentTimeMillisUnsafe(), ulidRandomBytes)))
+    uuidV4: (options) => sync2(() => makeUuid(v4Bytes, randomBytes, options?.format)),
+    uuidV7: (options) => clockWith((clock) => sync2(() => makeUuid((bytes) => uuidV7(clock.currentTimeMillisUnsafe(), bytes), randomBytes, options?.format))),
+    ulid: clockWith((clock) => sync2(() => ulid(clock.currentTimeMillisUnsafe(), ulidRandomBytes)))
   };
 };
 var fillRandom = (crypto, size) => {
@@ -548,7 +435,7 @@ var fillRandom = (crypto, size) => {
   }
   return bytes;
 };
-var layerWebCrypto = /* @__PURE__ */ effect(SecureRandom, /* @__PURE__ */ WebCrypto.use((crypto) => succeed4(make3((size) => fillRandom(crypto, size)))));
+var layerWebCrypto = /* @__PURE__ */ effect(SecureRandom, /* @__PURE__ */ WebCrypto.use((crypto) => succeed5(make3((size) => fillRandom(crypto, size)))));
 
 // ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/BigInt.js
 var BigInt2 = globalThis.BigInt;
@@ -711,7 +598,7 @@ __export(exports_Aead, {
 });
 
 // ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/crypto/CryptoError.js
-var TypeId2 = "~effect/crypto/CryptoError";
+var TypeId = "~effect/crypto/CryptoError";
 var ReasonTypeId = "~effect/crypto/CryptoError/Reason";
 
 class InvalidArgument extends (/* @__PURE__ */ TaggedError("InvalidArgument")) {
@@ -750,7 +637,7 @@ class NotExtractable extends (/* @__PURE__ */ TaggedError("NotExtractable")) {
 }
 
 class CryptoError extends (/* @__PURE__ */ TaggedError("CryptoError")) {
-  [TypeId2] = TypeId2;
+  [TypeId] = TypeId;
   cause = "cause" in this.reason ? this.reason.cause : undefined;
   get message() {
     return `${this.module}.${this.method}: ${this.reason.message}`;
@@ -1564,7 +1451,7 @@ var fromBytes = (module, method, proto, algorithm, bytes, check) => suspend(() =
   if (!(bytes instanceof Uint8Array))
     return invalidKey(module, method, "Expected the key as a Uint8Array");
   const problem = check(bytes);
-  return problem === undefined ? succeed4(makeBytes(proto, algorithm, copyBytes2(bytes))) : invalidKey(module, method, problem);
+  return problem === undefined ? succeed5(makeBytes(proto, algorithm, copyBytes2(bytes))) : invalidKey(module, method, problem);
 });
 var checkAesLength = (name, keyLength) => (algorithm) => {
   const length = algorithm.length;
@@ -1601,7 +1488,7 @@ var importedAlgorithm = (algorithm, cryptoKey) => {
 };
 var fromCryptoKey = (module, method, proto, algorithm, cryptoKey, expected) => suspend(() => {
   const problem = checkCryptoKey(cryptoKey, expected);
-  return problem === undefined ? succeed4(make8(proto, importedAlgorithm(algorithm, cryptoKey), {
+  return problem === undefined ? succeed5(make8(proto, importedAlgorithm(algorithm, cryptoKey), {
     _tag: "CryptoKey",
     cryptoKey
   })) : invalidKey(module, method, problem);
@@ -1610,7 +1497,7 @@ var exportRaw = async (subtle, cryptoKey) => new Uint8Array(await subtle.exportK
 var toBytes = (module, key, exportKey) => suspend(() => {
   const stored = material(key);
   if (stored._tag === "Bytes")
-    return succeed4(copyBytes2(stored.bytes));
+    return succeed5(copyBytes2(stored.bytes));
   if (!stored.cryptoKey.extractable)
     return notExtractable(module, "toBytes");
   return runWithReference(module, "toBytes", key.algorithm.name, (subtle) => exportKey(subtle, stored.cryptoKey));
@@ -1631,7 +1518,7 @@ var makeCache = (importKey) => {
 };
 
 // ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/crypto/Aead.js
-var TypeId3 = "~effect/crypto/Aead/Key";
+var TypeId2 = "~effect/crypto/Aead/Key";
 var aes128Gcm = {
   name: "aes128Gcm",
   keyLength: 16,
@@ -1660,8 +1547,8 @@ var xchacha20Poly13052 = {
   nonceLength: 24,
   implementation: /* @__PURE__ */ chachaImplementation(xchacha20Poly1305)
 };
-var KeyProto = /* @__PURE__ */ redactedProto(TypeId3, "Aead.Key");
-var isKey = (u) => hasProperty(u, TypeId3);
+var KeyProto = /* @__PURE__ */ redactedProto(TypeId2, "Aead.Key");
+var isKey = (u) => hasProperty(u, TypeId2);
 
 class Aead extends (/* @__PURE__ */ Service()("effect/crypto/Aead")) {
 }
@@ -1696,11 +1583,11 @@ var runImplementation = (method, implementation, key2, data, options) => {
   }
   const aad = options.aad ?? new Uint8Array(0);
   if (method === "encrypt") {
-    return sync(() => implementation.encrypt(stored.bytes, options.nonce, data, aad));
+    return sync2(() => implementation.encrypt(stored.bytes, options.nonce, data, aad));
   }
   return suspend(() => {
     const plaintext = implementation.decrypt(stored.bytes, options.nonce, data, aad);
-    return plaintext === undefined ? decryptionFailed() : succeed4(plaintext);
+    return plaintext === undefined ? decryptionFailed() : succeed5(plaintext);
   });
 };
 var layerWebCryptoWith = (options) => effect(Aead, gen(function* () {
@@ -1761,7 +1648,7 @@ __export(exports_Cipher, {
   layerWebCrypto: () => layerWebCrypto3,
   toBytes: () => toBytes3
 });
-var TypeId4 = "~effect/crypto/Cipher/Key";
+var TypeId3 = "~effect/crypto/Cipher/Key";
 var aes128Ctr = {
   name: "aes128Ctr",
   mode: "AES-CTR",
@@ -1782,8 +1669,8 @@ var aes256Cbc = {
   mode: "AES-CBC",
   keyLength: 32
 };
-var KeyProto2 = /* @__PURE__ */ redactedProto(TypeId4, "Cipher.Key");
-var isKey2 = (u) => hasProperty(u, TypeId4);
+var KeyProto2 = /* @__PURE__ */ redactedProto(TypeId3, "Cipher.Key");
+var isKey2 = (u) => hasProperty(u, TypeId3);
 
 class Cipher extends (/* @__PURE__ */ Service()("effect/crypto/Cipher")) {
 }
@@ -2004,7 +1891,7 @@ var layerWebCrypto4 = /* @__PURE__ */ effect(KeyAgreement, /* @__PURE__ */ gen(f
       }), onError).pipe(flatMap3((keys) => run2("KeyAgreement", "deriveSharedSecret", algorithm.name, crypto, async (subtle) => new Uint8Array(await subtle.deriveBits({
         name: specOf(algorithm).name,
         public: keys.publicKey
-      }, keys.privateKey, sharedSecretBits(algorithm))), (cause) => isOperationError(cause) ? invalidPeer("Invalid peer public key", cause) : onError(cause))), flatMap3((secret) => algorithm._tag === "X25519" && secret.every((byte) => byte === 0) ? fail5(invalidPeer("X25519 shared secret must not be all zeros")) : succeed4(secret)));
+      }, keys.privateKey, sharedSecretBits(algorithm))), (cause) => isOperationError(cause) ? invalidPeer("Invalid peer public key", cause) : onError(cause))), flatMap3((secret) => algorithm._tag === "X25519" && secret.every((byte) => byte === 0) ? fail5(invalidPeer("X25519 shared secret must not be all zeros")) : succeed5(secret)));
     }),
     publicKeyOf: (privateKey) => publicKeyOf(family, crypto, privateKey)
   });
@@ -2050,7 +1937,7 @@ __export(exports_Mac, {
   timingSafeEqual: () => timingSafeEqual,
   toBytes: () => toBytes5
 });
-var TypeId5 = "~effect/crypto/Mac/Key";
+var TypeId4 = "~effect/crypto/Mac/Key";
 var hmacSha1 = {
   name: "hmacSha1",
   hash: sha1
@@ -2067,8 +1954,8 @@ var hmacSha512 = {
   name: "hmacSha512",
   hash: sha512
 };
-var KeyProto3 = /* @__PURE__ */ redactedProto(TypeId5, "Mac.Key");
-var isKey3 = (u) => hasProperty(u, TypeId5);
+var KeyProto3 = /* @__PURE__ */ redactedProto(TypeId4, "Mac.Key");
+var isKey3 = (u) => hasProperty(u, TypeId4);
 var blockSizes = {
   MD5: 64,
   "SHA-1": 64,
@@ -2098,11 +1985,11 @@ var layerWebCryptoWith2 = (options) => effect(Mac, gen(function* () {
     generateKey: (algorithm) => map4(random.randomBytes(blockSizes[algorithm.hash.name]), (bytes) => makeBytes(KeyProto3, algorithm, bytes)),
     sign: (key, data) => {
       const tagOf = hmacTag(key);
-      return tagOf !== undefined ? sync(() => tagOf(data)) : run2("Mac", "sign", key.algorithm.name, crypto, async (subtle) => new Uint8Array(await subtle.sign("HMAC", await cryptoKeyFor(subtle, key), data)));
+      return tagOf !== undefined ? sync2(() => tagOf(data)) : run2("Mac", "sign", key.algorithm.name, crypto, async (subtle) => new Uint8Array(await subtle.sign("HMAC", await cryptoKeyFor(subtle, key), data)));
     },
     verify: (key, tag, data) => {
       const tagOf = hmacTag(key);
-      return tagOf !== undefined ? sync(() => timingSafeEqual(tagOf(data), tag)) : run2("Mac", "verify", key.algorithm.name, crypto, async (subtle) => subtle.verify("HMAC", await cryptoKeyFor(subtle, key), tag, data));
+      return tagOf !== undefined ? sync2(() => timingSafeEqual(tagOf(data), tag)) : run2("Mac", "verify", key.algorithm.name, crypto, async (subtle) => subtle.verify("HMAC", await cryptoKeyFor(subtle, key), tag, data));
     }
   });
 }));
@@ -2951,7 +2838,7 @@ var walk = /* @__PURE__ */ fnUntraced(function* (fs, compiled, options) {
   const isUnlisted = (value) => value === "." || value === ".." || isRoot(value);
   const probe = (parent, name, named) => {
     const path = toFsPath(join(parent, name));
-    return fs.stat(path).pipe(map4((info) => info.type), catchReason("PlatformError", "NotFound", () => fs.readLink(path).pipe(as("SymbolicLink"), catchIf(isNotLink, () => succeed4(undefined)))), catchIf(named ? isMissing : isIgnorable, () => succeed4(undefined)), map4((type) => type === undefined ? undefined : {
+    return fs.stat(path).pipe(map4((info) => info.type), catchReason("PlatformError", "NotFound", () => fs.readLink(path).pipe(as("SymbolicLink"), catchIf(isNotLink, () => succeed5(undefined)))), catchIf(named ? isMissing : isIgnorable, () => succeed5(undefined)), map4((type) => type === undefined ? undefined : {
       name,
       type
     }));
@@ -2968,7 +2855,7 @@ var walk = /* @__PURE__ */ fnUntraced(function* (fs, compiled, options) {
       }
     }
     const probed = listed ? [...literals].filter(isUnlisted) : [...literals];
-    return zipWith(listed ? catchIf(fs.readDirectoryEntries(toFsPath(relative)), named ? isMissing : isIgnorable, () => succeed4([])) : succeed4([]), forEach(probed, (name) => probe(relative, name, named), {
+    return zipWith(listed ? catchIf(fs.readDirectoryEntries(toFsPath(relative)), named ? isMissing : isIgnorable, () => succeed5([])) : succeed5([]), forEach(probed, (name) => probe(relative, name, named), {
       concurrency: 16
     }), (listing, found) => ({
       entries: sort([...listing, ...found.filter(isNotUndefined)], byName),
@@ -3006,22 +2893,22 @@ var walk = /* @__PURE__ */ fnUntraced(function* (fs, compiled, options) {
       return child(type === "Directory", false);
     }
     const path = toFsPath(relative);
-    return fs.stat(path).pipe(map4((info) => info.type === "Directory"), catchIf(isIgnorable, () => succeed4(false)), flatMap3((isDirectory) => {
+    return fs.stat(path).pipe(map4((info) => info.type === "Directory"), catchIf(isIgnorable, () => succeed5(false)), flatMap3((isDirectory) => {
       const resolved = child(isDirectory, type === "SymbolicLink");
       if (type === "SymbolicLink" || resolved?.next === undefined || result.globstar.size === 0) {
-        return succeed4(resolved);
+        return succeed5(resolved);
       }
-      return fs.readLink(path).pipe(as(child(isDirectory, true)), catchIf(isNotLink, () => succeed4(resolved)));
+      return fs.readLink(path).pipe(as(child(isDirectory, true)), catchIf(isNotLink, () => succeed5(resolved)));
     }));
   };
   let slots = DIRECTORY_CONCURRENCY;
   let finishing = false;
   const failed = makeUnsafe2();
-  const fork = (walk) => walk.pipe(onError((cause) => sync(() => {
+  const fork = (walk) => walk.pipe(onError((cause) => sync2(() => {
     if (!finishing) {
       doneUnsafe(failed, failCause(cause));
     }
-  })), ensuring(sync(() => {
+  })), ensuring(sync2(() => {
     slots++;
   })), forkChild);
   const directory = fnUntraced(function* (relative, states, excluded, named) {
@@ -3053,7 +2940,7 @@ var walk = /* @__PURE__ */ fnUntraced(function* (fs, compiled, options) {
           slots--;
           subtrees.push(join2(yield* fork(walk)));
         } else {
-          subtrees.push(succeed4(yield* walk));
+          subtrees.push(succeed5(yield* walk));
         }
       }
     }
@@ -3074,13 +2961,13 @@ var walk = /* @__PURE__ */ fnUntraced(function* (fs, compiled, options) {
     }
     return out;
   });
-  return yield* raceFirst(ensuring(directory("", compiled.initial, excludes.initial, true), sync(() => {
+  return yield* raceFirst(ensuring(directory("", compiled.initial, excludes.initial, true), sync2(() => {
     finishing = true;
   })), _await(failed));
 });
 
 // ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/PlatformError.js
-var TypeId6 = "~effect/PlatformError";
+var TypeId5 = "~effect/PlatformError";
 
 class BadArgument extends (/* @__PURE__ */ TaggedError("BadArgument")) {
   get message() {
@@ -3107,7 +2994,7 @@ class PlatformError extends (/* @__PURE__ */ TaggedError("PlatformError")) {
       });
     }
   }
-  [TypeId6] = TypeId6;
+  [TypeId5] = TypeId5;
   get message() {
     return this.reason.message;
   }
@@ -3116,8 +3003,8 @@ var systemError = (options) => new PlatformError(new SystemError(options));
 var badArgument = (options) => new PlatformError(new BadArgument(options));
 
 // ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/Sink.js
-var TypeId7 = "~effect/Sink";
-var endVoid = /* @__PURE__ */ succeed4([undefined]);
+var TypeId6 = "~effect/Sink";
+var endVoid = /* @__PURE__ */ succeed5([undefined]);
 var sinkVariance = {
   _A: identity,
   _In: identity,
@@ -3126,21 +3013,21 @@ var sinkVariance = {
   _R: identity
 };
 var SinkProto = {
-  [TypeId7]: sinkVariance,
+  [TypeId6]: sinkVariance,
   pipe() {
     return pipeArguments(this, arguments);
   }
 };
-var isSink = (u) => hasProperty(u, TypeId7);
+var isSink = (u) => hasProperty(u, TypeId6);
 var fromChannel2 = (channel) => fromTransform2((upstream, scope) => toTransform(channel)(upstream, scope).pipe(flatMap3(forever({
   disableYield: true
-})), catchDone(succeed4)));
+})), catchDone(succeed5)));
 var fromTransform2 = (transform) => {
   const self = Object.create(SinkProto);
   self.transform = transform;
   return self;
 };
-var toChannel = (self) => fromTransform((upstream, scope) => succeed4(flatMap3(self.transform(upstream, scope), done)));
+var toChannel = (self) => fromTransform((upstream, scope) => succeed5(flatMap3(self.transform(upstream, scope), done)));
 var drain = /* @__PURE__ */ fromTransform2((upstream) => catchDone(forever(upstream, {
   disableYield: true
 }), () => endVoid));
@@ -3153,7 +3040,7 @@ var forEachArray = (f) => fromTransform2((upstream) => upstream.pipe(flatMap3(f)
 var unwrap3 = (effect) => fromChannel2(unwrap(map4(effect, toChannel)));
 
 // ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/internal/rcRef.js
-var TypeId8 = "~effect/RcRef";
+var TypeId7 = "~effect/RcRef";
 var stateEmpty = {
   _tag: "Empty"
 };
@@ -3166,7 +3053,7 @@ var variance = {
 };
 
 class RcRefImpl {
-  [TypeId8] = variance;
+  [TypeId7] = variance;
   pipe() {
     return pipeArguments(this, arguments);
   }
@@ -3182,7 +3069,7 @@ class RcRefImpl {
     this.idleTimeToLive = idleTimeToLive;
   }
 }
-var make10 = (options) => withFiber((fiber) => {
+var make10 = (options) => withFiber2((fiber) => {
   const context = fiber.context;
   const scope = get(context, Scope);
   const ref = new RcRefImpl(options.acquire, context, scope, options.idleTimeToLive !== undefined ? fromInputUnsafe(options.idleTimeToLive) : undefined);
@@ -3190,10 +3077,10 @@ var make10 = (options) => withFiber((fiber) => {
     const state = ref.state;
     ref.state = stateClosed;
     if (state._tag === "Acquired")
-      return close(state.scope, void_);
+      return close(state.scope, void_2);
     if (state._tag === "Acquiring")
       return interrupt2(state.fiber);
-    return void_2;
+    return void_3;
   }), ref);
 });
 var getState = (self, restore) => {
@@ -3204,7 +3091,7 @@ var getState = (self, restore) => {
     case "Acquired": {
       const state = self.state;
       state.refCount++;
-      return state.fiber ? as(interrupt2(state.fiber), state) : succeed4(state);
+      return state.fiber ? as(interrupt2(state.fiber), state) : succeed5(state);
     }
     case "Acquiring": {
       const state = self.state;
@@ -3234,10 +3121,10 @@ var getState = (self, restore) => {
         };
         self.state = state;
         acquiring.acquired = state;
-        return succeed4(state);
+        return succeed5(state);
       }), onExit((exit) => {
         if (isSuccess2(exit))
-          return void_2;
+          return void_3;
         if (self.state === acquiring)
           self.state = stateEmpty;
         return close(scope, exit);
@@ -3250,58 +3137,58 @@ var getState = (self, restore) => {
 var awaitAcquiring = (self, acquiring, restore) => onExit(restore(join2(acquiring.fiber)), (exit) => {
   const acquired = acquiring.acquired;
   if (acquired !== undefined) {
-    return isFailure(exit) ? release(self, acquired) : void_2;
+    return isFailure(exit) ? release(self, acquired) : void_3;
   }
   if (--acquiring.awaiters > 0 || self.state !== acquiring)
-    return void_2;
+    return void_3;
   self.state = stateEmpty;
   return interrupt2(acquiring.fiber);
 });
-var get3 = (self_) => {
+var get2 = (self_) => {
   const self = self_;
   return uninterruptibleMask((restore) => flatMap3(scope, (scope) => flatMap3(getState(self, restore), (state) => as(addFinalizerExit(scope, () => release(self, state)), state.value))));
 };
 var release = (self, state) => {
   state.refCount--;
   if (state.refCount > 0) {
-    return void_2;
+    return void_3;
   }
   const idleTimeToLive = self.idleTimeToLive;
   if (idleTimeToLive === undefined || state.invalidated) {
     if (self.state === state) {
       self.state = stateEmpty;
     }
-    return close(state.scope, void_);
+    return close(state.scope, void_2);
   } else if (!isFinite(idleTimeToLive)) {
-    return void_2;
+    return void_3;
   }
   state.fiber = uninterruptibleMask((restore) => flatMap3(restore(sleep(idleTimeToLive)), () => {
     if (self.state === state && state.refCount === 0) {
       self.state = stateEmpty;
-      return ignoreCause(close(state.scope, void_), {
+      return ignoreCause(close(state.scope, void_2), {
         log: "Unhandled",
         message: "Unhandled error in RcRef finalizer"
       });
     }
-    return void_2;
-  })).pipe(ensuring(sync(() => {
+    return void_3;
+  })).pipe(ensuring(sync2(() => {
     state.fiber = undefined;
   })), runForkWith(self.context), runIn(self.scope));
-  return void_2;
+  return void_3;
 };
 
 // ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/RcRef.js
 var make11 = make10;
-var get4 = get3;
+var get3 = get2;
 
 // ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/FileSystem.js
-var TypeId9 = "~effect/FileSystem";
+var TypeId8 = "~effect/FileSystem";
 var FileSystem = /* @__PURE__ */ Service("effect/FileSystem");
 var make12 = (impl) => FileSystem.of({
   ...impl,
-  [TypeId9]: TypeId9,
+  [TypeId8]: TypeId8,
   glob: make9(impl),
-  exists: (path) => pipe(impl.access(path), as(true), catchTag("PlatformError", (e) => e.reason._tag === "NotFound" ? succeed4(false) : fail5(e))),
+  exists: (path) => pipe(impl.access(path), as(true), catchTag("PlatformError", (e) => e.reason._tag === "NotFound" ? succeed5(false) : fail5(e))),
   readFileString: (path, encoding) => flatMap3(impl.readFile(path), (_) => try_2({
     try: () => new TextDecoder(encoding).decode(_),
     catch: (cause) => badArgument({
@@ -3323,7 +3210,7 @@ var make12 = (impl) => FileSystem.of({
     let totalBytesRead = BigInt(0);
     const chunkSize = Number(BigInt(options?.chunkSize ?? 64 * 1024));
     const readChunk = file.readAlloc(chunkSize);
-    return fromPull(succeed4(flatMap3(suspend(() => {
+    return fromPull(succeed5(flatMap3(suspend(() => {
       if (bytesToRead !== undefined && bytesToRead <= totalBytesRead) {
         return done();
       }
@@ -3332,7 +3219,7 @@ var make12 = (impl) => FileSystem.of({
       onNone: () => done(),
       onSome: (buf) => {
         totalBytesRead += BigInt(buf.length);
-        return succeed4(of(buf));
+        return succeed5(of(buf));
       }
     }))));
   }, unwrap2),
@@ -3355,11 +3242,11 @@ class WatchBackend extends (/* @__PURE__ */ Service()("effect/FileSystem/WatchBa
 }
 
 // ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/Path.js
-var TypeId10 = "~effect/Path";
+var TypeId9 = "~effect/Path";
 var Path = /* @__PURE__ */ Service("effect/Path");
 var make13 = (impl) => Path.of({
   ...impl,
-  [TypeId10]: TypeId10,
+  [TypeId9]: TypeId9,
   resolveWithin(root, input) {
     if (impl.parse(input).root !== "")
       return none();
@@ -3370,179 +3257,122 @@ var make13 = (impl) => Path.of({
   }
 });
 
-// ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/FiberMap.js
-var TypeId11 = "~effect/FiberMap";
-var isFiberMap = (u) => hasProperty(u, TypeId11);
-var Proto = {
-  [TypeId11]: TypeId11,
-  [Symbol.iterator]() {
-    if (this.state._tag === "Closed") {
-      return empty();
-    }
-    return this.state.backing[Symbol.iterator]();
-  },
-  ...PipeInspectableProto,
-  toJSON() {
-    return {
-      _id: "FiberMap",
-      state: this.state
-    };
-  }
-};
-var makeUnsafe5 = (backing, deferred) => {
-  const self = Object.create(Proto);
-  self.state = {
-    _tag: "Open",
-    backing,
-    fibers: new Set
-  };
-  self.deferred = deferred;
-  return self;
-};
-var make14 = () => acquireRelease(sync(() => makeUnsafe5(empty2(), makeUnsafe2())), (map) => suspend(() => {
-  const state = map.state;
-  if (state._tag === "Closed")
-    return void_2;
-  map.state = {
-    _tag: "Closed"
-  };
-  return interruptAll(state.fibers).pipe(into(map.deferred));
-}));
-var internalFiberId = -1;
-var isInternalInterruption = /* @__PURE__ */ toPredicate(/* @__PURE__ */ compose(filterInterruptors, /* @__PURE__ */ has2(internalFiberId)));
-var setUnsafe = /* @__PURE__ */ dual((args) => isFiberMap(args[0]), (self, key, fiber, options) => {
-  if (self.state._tag === "Closed") {
-    fiber.interruptUnsafe(internalFiberId);
-    return;
-  }
-  const previous = get2(self.state.backing, key);
-  if (previous._tag === "Some") {
-    if (previous.value === fiber) {
-      return;
-    } else if (options?.onlyIfMissing === true) {
-      fiber.interruptUnsafe(internalFiberId);
-      return;
-    }
-  }
-  set(self.state.backing, key, fiber);
-  self.state.fibers.add(fiber);
-  if (previous._tag === "Some") {
-    previous.value.interruptUnsafe(internalFiberId);
-  }
-  fiber.addObserver((exit) => {
-    if (self.state._tag === "Closed") {
-      return;
-    }
-    self.state.fibers.delete(fiber);
-    const current = get2(self.state.backing, key);
-    if (isSome(current) && fiber === current.value) {
-      remove(self.state.backing, key);
-    }
-    if (isFailure(exit) && (options?.propagateInterruption === true ? !isInternalInterruption(exit.cause) : !hasInterruptsOnly(exit.cause))) {
-      doneUnsafe(self.deferred, exit);
-    }
-  });
-});
-var getUnsafe2 = /* @__PURE__ */ dual(2, (self, key) => {
-  return self.state._tag === "Closed" ? none() : get2(self.state.backing, key);
+// ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/ManagedRuntime.js
+var TypeId10 = "~effect/ManagedRuntime";
+var DisposingRuntimes = /* @__PURE__ */ Reference("effect/ManagedRuntime/DisposingRuntimes", {
+  defaultValue: () => new Set
 });
-var get5 = /* @__PURE__ */ dual(2, (self, key) => suspend(() => succeed4(getUnsafe2(self, key))));
-var hasUnsafe = /* @__PURE__ */ dual(2, (self, key) => self.state._tag === "Closed" ? false : has(self.state.backing, key));
-var has3 = /* @__PURE__ */ dual(2, (self, key) => sync(() => hasUnsafe(self, key)));
-var constInterruptedFiber = /* @__PURE__ */ function() {
-  let fiber = undefined;
-  return () => {
-    if (fiber === undefined) {
-      fiber = runFork(interrupt);
-    }
-    return fiber;
+var make14 = (layer, options) => {
+  const memoMap = options?.memoMap ?? makeMemoMapUnsafe();
+  const scope = makeUnsafe3("sequential");
+  const layerScope = forkUnsafe2(scope, "sequential");
+  const fiberScope = forkUnsafe2(scope, "parallel");
+  const managedFibers = new WeakSet;
+  const disposingFibers = new WeakSet;
+  const defaultRunOptions = {
+    onFiberStart(fiber) {
+      managedFibers.add(fiber);
+      if (disposingFibers.has(fiber))
+        return;
+      runIn(fiber, fiberScope);
+    }
   };
-}();
-var run3 = function() {
-  const self = arguments[0];
-  if (isEffect(arguments[2])) {
-    return runImpl(self, arguments[1], arguments[2], arguments[3]);
-  }
-  const key = arguments[1];
-  const options = arguments[2];
-  return (effect) => runImpl(self, key, effect, options);
-};
-var runImpl = (self, key, effect, options) => withFiber((parent) => {
-  if (self.state._tag === "Closed") {
-    return interrupt;
-  } else if (options?.onlyIfMissing === true && hasUnsafe(self, key)) {
-    return sync(constInterruptedFiber);
-  }
-  const fiber = forkUnsafe(parent, effect, options?.startImmediately ?? true, true);
-  setUnsafe(self, key, fiber, options);
-  return succeed4(fiber);
-});
-var size2 = (self) => sync(() => self.state._tag === "Closed" ? 0 : size(self.state.backing));
-
-// ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/Runtime.js
-var defaultTeardown = (exit, onExit) => {
-  if (isSuccess2(exit))
-    return onExit(0);
-  if (hasInterruptsOnly(exit.cause))
-    return onExit(130);
-  return onExit(getErrorExitCode(squash(exit.cause)));
-};
-var makeRunMain = (f) => dual((args) => isEffect(args[0]), (effect, options) => {
-  const main = options?.disableErrorReporting === true ? effect : tapCause(effect, (cause) => {
-    if (hasInterruptsOnly(cause))
-      return void_2;
-    const isReported = getErrorReported(squash(cause));
-    return isReported ? logError(cause) : void_2;
-  });
-  const teardown = options?.teardown ?? defaultTeardown;
-  runFork(withFiber((fiber) => {
-    try {
-      const keepAlive = globalThis.setInterval(constVoid, 2147483647);
-      fiber.addObserver(() => {
-        clearInterval(keepAlive);
+  const mergeRunOptions = (options) => options ? {
+    ...options,
+    onFiberStart: options.onFiberStart ? (fiber) => {
+      defaultRunOptions.onFiberStart(fiber);
+      options.onFiberStart(fiber);
+    } : defaultRunOptions.onFiberStart
+  } : defaultRunOptions;
+  let buildFiber;
+  let disposed;
+  const contextEffect = withFiber2((fiber) => {
+    if (!buildFiber) {
+      buildFiber = runFork(tap(buildWithMemoMap(layer, memoMap, layerScope), (context) => sync2(() => {
+        self.cachedContext = context;
+      })), {
+        scheduler: fiber.cache.scheduler,
+        onFiberStart(fiber) {
+          managedFibers.add(fiber);
+          runIn(fiber, fiberScope);
+        }
       });
-    } catch {}
-    f({
-      fiber,
-      teardown
-    });
-    return main;
-  }));
-});
-var errorExitCode = "~effect/Runtime/errorExitCode";
-var getErrorExitCode = (u) => {
-  if (typeof u === "object" && u !== null && errorExitCode in u) {
-    const code = u[errorExitCode];
-    if (typeof code === "number") {
-      return code;
     }
-  }
-  return 1;
-};
-var errorReported = "~effect/Runtime/errorReported";
-var getErrorReported = (u) => {
-  if (typeof u === "object" && u !== null && errorReported in u) {
-    const isReported = u[errorReported];
-    if (typeof isReported === "boolean") {
-      return isReported;
+    return flatten2(await_(buildFiber));
+  });
+  const self = {
+    [TypeId10]: TypeId10,
+    memoMap,
+    scope,
+    contextEffect,
+    cachedContext: undefined,
+    context() {
+      return self.cachedContext === undefined ? runPromise(self.contextEffect) : Promise.resolve(self.cachedContext);
+    },
+    dispose() {
+      return runPromise(self.disposeEffect);
+    },
+    [Symbol.asyncDispose]() {
+      return self.dispose();
+    },
+    disposeEffect: withFiber2((fiber) => {
+      if (disposed !== undefined) {
+        if (fiber.getRef(DisposingRuntimes).has(self))
+          return void_3;
+        for (let current = fiber;current; current = current._parent) {
+          if (managedFibers.has(current))
+            return void_3;
+        }
+        return _await(disposed);
+      }
+      fiberEnterUninterruptibleUnsafe(fiber);
+      const done = disposed = makeUnsafe2();
+      for (let current = fiber;current; current = current._parent) {
+        disposingFibers.add(current);
+        scopeRemoveFinalizerUnsafe(fiberScope, current);
+      }
+      self.contextEffect = die("ManagedRuntime disposed");
+      self.cachedContext = undefined;
+      return close(self.scope, void_2).pipe(provideService(DisposingRuntimes, new Set(fiber.getRef(DisposingRuntimes)).add(self)), ensuring(done2(done, void_2)));
+    }),
+    runFork(effect, options) {
+      return self.cachedContext === undefined ? runFork(provide2(self, effect), mergeRunOptions(options)) : runForkWith(self.cachedContext)(effect, mergeRunOptions(options));
+    },
+    runCallback(effect, options) {
+      return self.cachedContext === undefined ? runCallback(provide2(self, effect), mergeRunOptions(options)) : runCallbackWith(self.cachedContext)(effect, mergeRunOptions(options));
+    },
+    runSyncExit(effect) {
+      return self.cachedContext === undefined ? runSyncExit(provide2(self, effect)) : runSyncExitWith(self.cachedContext)(effect);
+    },
+    runSync(effect) {
+      return self.cachedContext === undefined ? runSync(provide2(self, effect)) : runSyncWith(self.cachedContext)(effect);
+    },
+    runPromiseExit(effect, options) {
+      return self.cachedContext === undefined ? runPromiseExit(provide2(self, effect), mergeRunOptions(options)) : runPromiseExitWith(self.cachedContext)(effect, mergeRunOptions(options));
+    },
+    runPromise(effect, options) {
+      return self.cachedContext === undefined ? runPromise(provide2(self, effect), mergeRunOptions(options)) : runPromiseWith(self.cachedContext)(effect, mergeRunOptions(options));
     }
-  }
-  return true;
+  };
+  return self;
 };
+function provide2(managed, effect) {
+  return flatMap3(managed.contextEffect, (context) => provideContext(effect, context));
+}
 
 // ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/Stdio.js
-var TypeId12 = "~effect/Stdio";
-var Stdio = /* @__PURE__ */ Service(TypeId12);
+var TypeId11 = "~effect/Stdio";
+var Stdio = /* @__PURE__ */ Service(TypeId11);
 var make15 = (options) => ({
-  [TypeId12]: TypeId12,
-  stdinIsTerminal: succeed4(false),
-  stdoutIsTerminal: succeed4(false),
-  stderrIsTerminal: succeed4(false),
+  [TypeId11]: TypeId11,
+  stdinIsTerminal: succeed5(false),
+  stdoutIsTerminal: succeed5(false),
+  stderrIsTerminal: succeed5(false),
   ...options
 });
 
 // ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/Terminal.js
-var TypeId13 = "~effect/Terminal";
+var TypeId12 = "~effect/Terminal";
 var QuitErrorTypeId = "~effect/Terminal/QuitError";
 
 class QuitError extends (/* @__PURE__ */ Error3("QuitError")({
@@ -3553,7 +3383,7 @@ class QuitError extends (/* @__PURE__ */ Error3("QuitError")({
 var Terminal = /* @__PURE__ */ Service("effect/Terminal");
 var make16 = (impl) => Terminal.of({
   ...impl,
-  [TypeId13]: TypeId13
+  [TypeId12]: TypeId12
 });
 // ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/crypto/Kdf.js
 class Kdf extends (/* @__PURE__ */ Service()("effect/crypto/Kdf")) {
@@ -3589,7 +3419,7 @@ var webCryptoParams = (algorithm, options) => algorithm._tag === "Hkdf" ? {
   salt: options.salt,
   iterations: algorithm.iterations
 };
-var layerWebCrypto8 = /* @__PURE__ */ effect(Kdf, /* @__PURE__ */ WebCrypto.use((crypto) => succeed4(Kdf.of({
+var layerWebCrypto8 = /* @__PURE__ */ effect(Kdf, /* @__PURE__ */ WebCrypto.use((crypto) => succeed5(Kdf.of({
   derive: (algorithm, secret, options) => suspend(() => {
     const failure = checkArguments2(algorithm, options);
     if (failure !== undefined)
@@ -3618,9 +3448,9 @@ var nodeHashNames = {
   "SHA-512": "sha512"
 };
 var nodeDigest = (algorithm, data) => new Uint8Array(NodeCrypto.createHash(nodeHashNames[algorithm.name]).update(data).digest());
-var layerDigest = /* @__PURE__ */ succeed3(Digest, {
-  digest: (algorithm, data) => sync(() => nodeDigest(algorithm, data)),
-  digestHex: (algorithm, data) => sync(() => NodeCrypto.createHash(nodeHashNames[algorithm.name]).update(data).digest("hex"))
+var layerDigest = /* @__PURE__ */ succeed4(Digest, {
+  digest: (algorithm, data) => sync2(() => nodeDigest(algorithm, data)),
+  digestHex: (algorithm, data) => sync2(() => NodeCrypto.createHash(nodeHashNames[algorithm.name]).update(data).digest("hex"))
 });
 var nodeHmac = (hash, key, data) => new Uint8Array(NodeCrypto.createHmac(nodeHashNames[hash], key).update(data).digest());
 var layerMac = /* @__PURE__ */ layerWebCryptoWith2({
@@ -3673,7 +3503,7 @@ var argon2id = (algorithm, secret, options) => callback((resume) => {
       if (cause)
         resume(argon2Failure(cause));
       else
-        resume(succeed4(new Uint8Array(key.buffer, key.byteOffset, key.length)));
+        resume(succeed5(new Uint8Array(key.buffer, key.byteOffset, key.length)));
     });
   } catch (cause) {
     resume(argon2Failure(cause));
@@ -3728,31 +3558,6 @@ var layerSignature = /* @__PURE__ */ layerWebCrypto7.pipe(/* @__PURE__ */ provid
 var layerKeyAgreement = /* @__PURE__ */ layerWebCrypto4.pipe(/* @__PURE__ */ provide(layerSecureRandom));
 var layerKeyWrap = /* @__PURE__ */ layerWebCrypto6.pipe(/* @__PURE__ */ provide(layerSecureRandom));
 var layer4 = /* @__PURE__ */ mergeAll(layerSecureRandom, layerDigest, layerMac, layerKdf, layerAead, layerCipher, layerSignature, layerKeyAgreement, layerKeyWrap);
-// ../../../../node_modules/.bun/@effect+platform-node-shared@4.1.2+edf248c88a527e3e/node_modules/@effect/platform-node-shared/dist/NodeRuntime.js
-var runMain = /* @__PURE__ */ makeRunMain(({
-  fiber,
-  teardown
-}) => {
-  let receivedSignal = false;
-  fiber.addObserver((exit) => {
-    process.removeListener("SIGINT", onSigint);
-    process.removeListener("SIGTERM", onSigint);
-    teardown(exit, (code) => {
-      if (receivedSignal || code !== 0) {
-        process.exit(code);
-      }
-    });
-  });
-  function onSigint() {
-    receivedSignal = true;
-    fiber.interruptUnsafe(fiber.id);
-  }
-  process.on("SIGINT", onSigint);
-  process.on("SIGTERM", onSigint);
-});
-
-// ../../../../node_modules/.bun/@effect+platform-node@4.1.2+22a1c27d4b1c9267/node_modules/@effect/platform-node/dist/NodeRuntime.js
-var runMain2 = runMain;
 // ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/process/ChildProcessSpawner.js
 var ExitCode = /* @__PURE__ */ nominal();
 var ProcessId = /* @__PURE__ */ nominal();
@@ -3981,17 +3786,17 @@ var parseTemplate = (texts, values) => {
 };
 
 // ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/process/ChildProcess.js
-var TypeId14 = "~effect/process/ChildProcess";
-var Proto2 = {
+var TypeId13 = "~effect/process/ChildProcess";
+var Proto = {
   .../* @__PURE__ */ Prototype({
     label: "Command",
     evaluate(fiber) {
       return getUnsafe(fiber.context, ChildProcessSpawner).spawn(this);
     }
   }),
-  [TypeId14]: TypeId14
+  [TypeId13]: TypeId13
 };
-var makeStandardCommand = (command, args, options) => Object.assign(Object.create(Proto2), {
+var makeStandardCommand = (command, args, options) => Object.assign(Object.create(Proto), {
   _tag: "StandardCommand",
   command,
   args,
@@ -4153,10 +3958,10 @@ var fromWritableChannel = (options) => fromTransform((pull) => {
     writable,
     pull
   });
-  return succeed4(options.endOnDone === false ? write : onError(write, (cause) => isDoneCause(cause) ? void_2 : releaseWritable(writable)));
+  return succeed5(options.endOnDone === false ? write : onError(write, (cause) => isDoneCause(cause) ? void_3 : releaseWritable(writable)));
 });
 var releaseWritable = (writable) => callback((resume) => {
-  const onDestroyed = () => resume(void_2);
+  const onDestroyed = () => resume(void_3);
   if (writable.closed) {
     const cleanup = finished(writable, {
       readable: false
@@ -4168,7 +3973,7 @@ var releaseWritable = (writable) => callback((resume) => {
     destroyStream(writable, constVoid, onDestroyed);
   }
 });
-var pullIntoWritable = (options) => withFiber((fiber) => {
+var pullIntoWritable = (options) => withFiber2((fiber) => {
   const dispatcher = fiber.currentDispatcher;
   const completion = makeUnsafe2();
   const failure = makeUnsafe2();
@@ -4185,7 +3990,7 @@ var pullIntoWritable = (options) => withFiber((fiber) => {
     if (error) {
       onError(error);
     } else {
-      doneUnsafe(completion, void_2);
+      doneUnsafe(completion, void_3);
     }
   });
   return options.pull.pipe(flatMap3((chunk) => {
@@ -4218,11 +4023,11 @@ var pullIntoWritable = (options) => withFiber((fiber) => {
           }
         }
         if (!cancelled) {
-          resume(void_2);
+          resume(void_3);
         }
       };
       loop();
-      return sync(() => {
+      return sync2(() => {
         cancelled = true;
         options.writable.off("drain", loop);
         options.writable.off("finish", onFinish);
@@ -4233,7 +4038,7 @@ var pullIntoWritable = (options) => withFiber((fiber) => {
   }), options.endOnDone !== false ? catchDone((_) => {
     options.writable.end();
     return andThen(_await(completion), done(_));
-  }) : identity, raceFirst(_await(failure)), ensuring(sync(() => {
+  }) : identity, raceFirst(_await(failure)), ensuring(sync2(() => {
     cleanup();
     const removeErrorListener = () => {
       options.writable.off("error", onStreamError);
@@ -4296,9 +4101,9 @@ var readableToPullUnsafe = (options) => {
         break;
       chunk.push(item);
     }
-    return succeed4(chunk);
+    return succeed5(chunk);
   });
-  return as(addFinalizer(options.scope, sync(() => {
+  return as(addFinalizer(options.scope, sync2(() => {
     readable.off("readable", onReadable);
     if (closeOnDone) {
       destroyStream(readable, cleanup);
@@ -4480,7 +4285,7 @@ var make19 = /* @__PURE__ */ gen(function* () {
     if (additionalFds.length === 0) {
       return {
         getInputFd: () => drain,
-        getOutputFd: () => empty5
+        getOutputFd: () => empty4
       };
     }
     const inputSinks = new Map;
@@ -4500,10 +4305,10 @@ var make19 = /* @__PURE__ */ gen(function* () {
         });
       }
       inputSinks.set(fd, sink);
-      return void_2;
+      return void_3;
     });
     const setupOutput = (fd, nodeStream, sink) => {
-      let stream = empty5;
+      let stream = empty4;
       if (nodeStream && "read" in nodeStream) {
         const passThrough = new PassThrough;
         let error = undefined;
@@ -4549,7 +4354,7 @@ var make19 = /* @__PURE__ */ gen(function* () {
     }
     return {
       getInputFd: (fd) => inputSinks.get(fd) ?? drain,
-      getOutputFd: (fd) => outputStreams.get(fd) ?? empty5
+      getOutputFd: (fd) => outputStreams.get(fd) ?? empty4
     };
   });
   const setupChildStdin = (command, childProcess, config, inputFailure) => suspend(() => {
@@ -4566,7 +4371,7 @@ var make19 = /* @__PURE__ */ gen(function* () {
     if (isStream(config.stream)) {
       return as(runInputStream(config.stream, sink, inputFailure), sink);
     }
-    return succeed4(sink);
+    return succeed5(sink);
   });
   const setupChildOutputStreams = (command, childProcess, stdoutConfig, stderrConfig) => {
     let stdout = childProcess.stdout ? (() => {
@@ -4577,7 +4382,7 @@ var make19 = /* @__PURE__ */ gen(function* () {
         evaluate: () => passThrough,
         onError: (error) => toPlatformError("fromReadable(stdout)", toError(error), command)
       });
-    })() : empty5;
+    })() : empty4;
     let stderr = childProcess.stderr ? (() => {
       const passThrough = new PassThrough;
       childProcess.stderr.on("error", (error) => passThrough.destroy(error));
@@ -4586,14 +4391,14 @@ var make19 = /* @__PURE__ */ gen(function* () {
         evaluate: () => passThrough,
         onError: (error) => toPlatformError("fromReadable(stderr)", toError(error), command)
       });
-    })() : empty5;
+    })() : empty4;
     if (isSink(stdoutConfig.stream)) {
       stdout = transduce(stdout, stdoutConfig.stream);
     }
     if (isSink(stderrConfig.stream)) {
       stderr = transduce(stderr, stderrConfig.stream);
     }
-    const all = merge(stdout, stderr);
+    const all = merge2(stdout, stderr);
     return {
       stdout,
       stderr,
@@ -4612,12 +4417,12 @@ var make19 = /* @__PURE__ */ gen(function* () {
       resume(fail5(toPlatformError("spawn", error, command)));
     });
     handle.on("exit", (...args) => {
-      doneUnsafe(deferred, succeed2(args));
+      doneUnsafe(deferred, succeed3(args));
     });
     handle.on("spawn", () => {
-      resume(succeed4([handle, deferred]));
+      resume(succeed5([handle, deferred]));
     });
-    return sync(() => {
+    return sync2(() => {
       handle.kill("SIGTERM");
     });
   });
@@ -4628,7 +4433,7 @@ var make19 = /* @__PURE__ */ gen(function* () {
           if (error) {
             resume(fail5(toPlatformError("kill", toError(error), command)));
           } else {
-            resume(void_2);
+            resume(void_3);
           }
         });
       });
@@ -4655,7 +4460,7 @@ var make19 = /* @__PURE__ */ gen(function* () {
       const error = new globalThis.Error("Failed to kill child process");
       return fail5(toPlatformError("kill", error, command));
     }
-    return void_2;
+    return void_3;
   });
   const awaitProcessExit = (command, childProcess, timeoutMillis) => callback((resume) => {
     const deadline = Date.now() + timeoutMillis;
@@ -4668,17 +4473,17 @@ var make19 = /* @__PURE__ */ gen(function* () {
       clearTimeout(timer);
       if (Date.now() >= deadline || !isProcessAlive(command, childProcess)) {
         stop();
-        resume(void_2);
+        resume(void_3);
         return;
       }
       timer = setTimeout(poll, processGroupPollIntervalMillis);
     };
     childProcess.on("exit", poll);
     poll();
-    return sync(stop);
+    return sync2(stop);
   });
   const terminateProcessGroup = fnUntraced(function* (command, childProcess, exitSignal, options) {
-    const signalGroup = (signal) => ownsProcessGroup(command, childProcess) ? killProcessGroup(command, childProcess, signal).pipe(catch_((error) => hasExited(childProcess) && isUnsignallableProcessGroup(error.cause) ? void_2 : killProcess(command, childProcess, signal))) : killProcess(command, childProcess, signal);
+    const signalGroup = (signal) => ownsProcessGroup(command, childProcess) ? killProcessGroup(command, childProcess, signal).pipe(catch_((error) => hasExited(childProcess) && isUnsignallableProcessGroup(error.cause) ? void_3 : killProcess(command, childProcess, signal))) : killProcess(command, childProcess, signal);
     yield* signalGroup(options?.killSignal ?? "SIGTERM");
     if (isUndefined(options?.forceKillAfter)) {
       yield* _await(exitSignal);
@@ -4764,13 +4569,13 @@ var make19 = /* @__PURE__ */ gen(function* () {
             }
           });
         }
-        const reref = sync(() => {
+        const reref = sync2(() => {
           if (!isReferenced) {
             childProcess.ref();
             isReferenced = true;
           }
         });
-        const unref = sync(() => {
+        const unref = sync2(() => {
           if (isReferenced) {
             childProcess.unref();
             isReferenced = false;
@@ -4794,7 +4599,7 @@ var make19 = /* @__PURE__ */ gen(function* () {
             return _await(inputFailure);
           }
           if (isNotNull(code)) {
-            return succeed4(ExitCode(code));
+            return succeed5(ExitCode(code));
           }
           const error = new globalThis.Error(`Process interrupted due to receipt of signal: '${signal}'`);
           return fail5(toPlatformError("exitCode", error, cmd));
@@ -4825,7 +4630,7 @@ var make19 = /* @__PURE__ */ gen(function* () {
           const command = pipeline[i];
           const options = pipeOptions[i] ?? {};
           const stdinConfig = resolveStdinOption(command.options);
-          const sourceStream = unwrap2(succeed4(getSourceStream(handles[handles.length - 1], options.from)));
+          const sourceStream = unwrap2(succeed5(getSourceStream(handles[handles.length - 1], options.from)));
           const toOption = options.to ?? "stdin";
           if (toOption === "stdin") {
             handles.push(yield* spawnCommand(make18(command.command, command.args, {
@@ -5011,7 +4816,7 @@ var removeFactory = (method) => {
     force: options?.force ?? false
   });
 };
-var remove2 = /* @__PURE__ */ removeFactory("remove");
+var remove = /* @__PURE__ */ removeFactory("remove");
 var makeTempDirectoryScoped = /* @__PURE__ */ (() => {
   const makeDirectory = /* @__PURE__ */ makeTempDirectoryFactory("makeTempDirectoryScoped");
   const removeDirectory = /* @__PURE__ */ removeFactory("makeTempDirectoryScoped");
@@ -5064,7 +4869,7 @@ var noFollowFlags = (method, flag) => suspend(() => {
       description: "noFollow is not supported on this platform"
     }));
   }
-  return succeed4(openFlagBits(flag) | O_NOFOLLOW);
+  return succeed5(openFlagBits(flag) | O_NOFOLLOW);
 });
 var openFactory = (method) => {
   const nodeOpen = effectify(NFS.open, handleErrnoException("FileSystem", method), handleBadArgument(method));
@@ -5117,7 +4922,7 @@ var makeFile = /* @__PURE__ */ (() => {
           }));
         }
         this.position = position;
-        return succeed4(position);
+        return succeed5(position);
       });
     }
     read(buffer, options) {
@@ -5186,7 +4991,7 @@ var makeFile = /* @__PURE__ */ (() => {
     write(buffer) {
       return suspend(() => {
         const position = this.position;
-        return flatMap3(this.append ? succeed4(undefined) : positionToNumber(position, "write"), (nodePosition) => map4(nodeWrite(this.fd, buffer, undefined, undefined, nodePosition), (bytesWritten) => {
+        return flatMap3(this.append ? succeed5(undefined) : positionToNumber(position, "write"), (nodePosition) => map4(nodeWrite(this.fd, buffer, undefined, undefined, nodePosition), (bytesWritten) => {
           if (!this.append) {
             this.position = position + BigInt(bytesWritten);
           }
@@ -5197,7 +5002,7 @@ var makeFile = /* @__PURE__ */ (() => {
     writeAllChunk(buffer) {
       return suspend(() => {
         const position = this.position;
-        return flatMap3(this.append ? succeed4(undefined) : positionToNumber(position, "writeAll"), (nodePosition) => flatMap3(nodeWriteAll(this.fd, buffer, undefined, undefined, nodePosition), (bytesWritten) => {
+        return flatMap3(this.append ? succeed5(undefined) : positionToNumber(position, "writeAll"), (nodePosition) => flatMap3(nodeWriteAll(this.fd, buffer, undefined, undefined, nodePosition), (bytesWritten) => {
           if (bytesWritten === 0) {
             return fail5(systemError({
               module: "FileSystem",
@@ -5210,12 +5015,12 @@ var makeFile = /* @__PURE__ */ (() => {
           if (!this.append) {
             this.position = position + BigInt(bytesWritten);
           }
-          return bytesWritten < buffer.length ? this.writeAllChunk(buffer.subarray(bytesWritten)) : void_2;
+          return bytesWritten < buffer.length ? this.writeAllChunk(buffer.subarray(bytesWritten)) : void_3;
         }));
       });
     }
     writeAll(buffer) {
-      return buffer.length === 0 ? void_2 : this.writeAllChunk(buffer);
+      return buffer.length === 0 ? void_3 : this.writeAllChunk(buffer);
     }
   }
   return (fd, append) => new FileImpl(fd, append);
@@ -5260,7 +5065,7 @@ var readFile2 = (path) => callback((resume, signal) => {
       if (err) {
         resume(fail5(handleErrnoException("FileSystem", "readFile")(err, [path])));
       } else {
-        resume(succeed4(data));
+        resume(succeed5(data));
       }
     });
   } catch (err) {
@@ -5319,7 +5124,7 @@ var utimes2 = /* @__PURE__ */ (() => {
   const nodeUtimes = /* @__PURE__ */ effectify(NFS.utimes, /* @__PURE__ */ handleErrnoException("FileSystem", "utime"), /* @__PURE__ */ handleBadArgument("utime"));
   return (path, atime, mtime) => nodeUtimes(path, atime, mtime);
 })();
-var watchNode = (path, info, options) => callback2((queue) => acquireRelease(sync(() => {
+var watchNode = (path, info, options) => callback2((queue) => acquireRelease(sync2(() => {
   const directory = info.type === "Directory" ? path : Path2.dirname(path);
   const watcher = NFS.watch(path, {
     recursive: options?.recursive ?? false
@@ -5362,7 +5167,7 @@ var watchNode = (path, info, options) => callback2((queue) => acquireRelease(syn
     endUnsafe(queue);
   });
   return watcher;
-}), (watcher) => sync(() => watcher.close())).pipe(tap(() => sync(() => options?.onReady?.()))));
+}), (watcher) => sync2(() => watcher.close())).pipe(tap(() => sync2(() => options?.onReady?.()))));
 var watch2 = (backend, path, options) => all2([stat2(path), serviceOption(WatchBackend)]).pipe(map4(([stat, callerBackend]) => orElse(callerBackend, () => backend).pipe(flatMap((_) => _.register(path, stat, options)), getOrElse(() => watchNode(path, stat, options)))), unwrap2);
 var writeFile2 = (path, data, options) => callback((resume, signal) => {
   try {
@@ -5374,7 +5179,7 @@ var writeFile2 = (path, data, options) => callback((resume, signal) => {
       if (err) {
         resume(fail5(handleErrnoException("FileSystem", "writeFile")(err, [path])));
       } else {
-        resume(void_2);
+        resume(void_3);
       }
     });
   } catch (err) {
@@ -5400,7 +5205,7 @@ var makeFileSystem = /* @__PURE__ */ map4(/* @__PURE__ */ serviceOption(WatchBac
   readFile: readFile2,
   readLink,
   realPath,
-  remove: remove2,
+  remove,
   rename: rename2,
   stat: stat2,
   symlink: symlink2,
@@ -5441,15 +5246,15 @@ var fileUrlOps = (windows) => ({
     })
   })
 });
-var layerPosix = /* @__PURE__ */ succeed3(Path)(/* @__PURE__ */ make13({
+var layerPosix = /* @__PURE__ */ succeed4(Path)(/* @__PURE__ */ make13({
   ...NodePath.posix,
   .../* @__PURE__ */ fileUrlOps(false)
 }));
-var layerWin32 = /* @__PURE__ */ succeed3(Path)(/* @__PURE__ */ make13({
+var layerWin32 = /* @__PURE__ */ succeed4(Path)(/* @__PURE__ */ make13({
   ...NodePath.win32,
   .../* @__PURE__ */ fileUrlOps(true)
 }));
-var layer8 = /* @__PURE__ */ succeed3(Path)(/* @__PURE__ */ make13({
+var layer8 = /* @__PURE__ */ succeed4(Path)(/* @__PURE__ */ make13({
   ...NodePath,
   .../* @__PURE__ */ fileUrlOps(undefined)
 }));
@@ -5458,11 +5263,11 @@ var layer8 = /* @__PURE__ */ succeed3(Path)(/* @__PURE__ */ make13({
 var layer9 = layer8;
 
 // ../../../../node_modules/.bun/@effect+platform-node-shared@4.1.2+edf248c88a527e3e/node_modules/@effect/platform-node-shared/dist/NodeStdio.js
-var layer10 = /* @__PURE__ */ succeed3(Stdio, /* @__PURE__ */ make15({
-  args: /* @__PURE__ */ sync(() => process.argv.slice(2)),
-  stdinIsTerminal: /* @__PURE__ */ sync(() => process.stdin.isTTY === true),
-  stdoutIsTerminal: /* @__PURE__ */ sync(() => process.stdout.isTTY === true),
-  stderrIsTerminal: /* @__PURE__ */ sync(() => process.stderr.isTTY === true),
+var layer10 = /* @__PURE__ */ succeed4(Stdio, /* @__PURE__ */ make15({
+  args: /* @__PURE__ */ sync2(() => process.argv.slice(2)),
+  stdinIsTerminal: /* @__PURE__ */ sync2(() => process.stdin.isTTY === true),
+  stdoutIsTerminal: /* @__PURE__ */ sync2(() => process.stdout.isTTY === true),
+  stderrIsTerminal: /* @__PURE__ */ sync2(() => process.stderr.isTTY === true),
   stdout: (options) => fromWritable({
     evaluate: () => process.stdout,
     onError: (cause) => systemError({
@@ -5513,9 +5318,9 @@ var make20 = /* @__PURE__ */ fnUntraced(function* (shouldQuit = defaultShouldQui
     }
   };
   stdin.once("end", onStdinEnd);
-  yield* addFinalizer2(() => sync(() => stdin.off("end", onStdinEnd)));
+  yield* addFinalizer2(() => sync2(() => stdin.off("end", onStdinEnd)));
   const rlRef = yield* make11({
-    acquire: acquireRelease(sync(() => {
+    acquire: acquireRelease(sync2(() => {
       const rl = readline.createInterface({
         input: stdin,
         escapeCodeTimeout: 50
@@ -5538,7 +5343,7 @@ var make20 = /* @__PURE__ */ fnUntraced(function* (shouldQuit = defaultShouldQui
       rl,
       onClose,
       onLine
-    }) => sync(() => {
+    }) => sync2(() => {
       readlineActive = false;
       rl.off("line", onLine);
       rl.off("close", onClose);
@@ -5549,7 +5354,7 @@ var make20 = /* @__PURE__ */ fnUntraced(function* (shouldQuit = defaultShouldQui
     })),
     idleTimeToLive: "10 millis"
   });
-  const setRawMode = (enabled) => sync(() => {
+  const setRawMode = (enabled) => sync2(() => {
     if (stdin.isTTY)
       stdin.setRawMode(enabled);
   });
@@ -5557,15 +5362,15 @@ var make20 = /* @__PURE__ */ fnUntraced(function* (shouldQuit = defaultShouldQui
     acquire: acquireRelease(setRawMode(true), () => setRawMode(false)),
     idleTimeToLive: "10 millis"
   });
-  const columns = sync(() => stdout.columns ?? 0);
-  const rows = sync(() => stdout.rows ?? 0);
+  const columns = sync2(() => stdout.columns ?? 0);
+  const rows = sync2(() => stdout.rows ?? 0);
   const size = gen(function* () {
     const queue = yield* sliding(1);
     const onResize = () => offerUnsafe(queue, {
       columns: stdout.columns ?? 0,
       rows: stdout.rows ?? 0
     });
-    yield* addFinalizer2(() => sync(() => {
+    yield* addFinalizer2(() => sync2(() => {
       stdout.off("resize", onResize);
       endUnsafe(queue);
     }));
@@ -5595,7 +5400,7 @@ var make20 = /* @__PURE__ */ fnUntraced(function* (shouldQuit = defaultShouldQui
       clearInterval(keepAlive);
       endUnsafe(queue);
     };
-    yield* addFinalizer2(() => sync(() => {
+    yield* addFinalizer2(() => sync2(() => {
       clearInterval(keepAlive);
       stdin.off("keypress", handleKeypress);
       stdin.off("end", handleEnd);
@@ -5604,18 +5409,18 @@ var make20 = /* @__PURE__ */ fnUntraced(function* (shouldQuit = defaultShouldQui
     if (inputEnded) {
       handleEnd();
     } else {
-      yield* get4(rlRef);
-      yield* get4(rawModeRef);
+      yield* get3(rlRef);
+      yield* get3(rawModeRef);
       stdin.once("end", handleEnd);
     }
     return queue;
   });
   const readLine = suspend(() => poll(lines).pipe(flatMap3(match2({
-    onNone: () => scoped(andThen(get4(rlRef), take(lines))),
-    onSome: succeed4
+    onNone: () => scoped(andThen(get3(rlRef), take(lines))),
+    onSome: succeed5
   })), mapError2(() => new QuitError({}))));
   const display = (prompt) => uninterruptible(callback((resume) => {
-    stdout.write(prompt, (err) => isNullish(err) ? resume(void_2) : resume(fail5(badArgument({
+    stdout.write(prompt, (err) => isNullish(err) ? resume(void_3) : resume(fail5(badArgument({
       module: "Terminal",
       method: "display",
       description: "Failed to write prompt to stdout",
@@ -5642,7 +5447,7 @@ var layer13 = layer12;
 
 // ../../../../node_modules/.bun/@effect+platform-node@4.1.2+22a1c27d4b1c9267/node_modules/@effect/platform-node/dist/NodeServices.js
 var layer14 = /* @__PURE__ */ provideMerge(layer5, /* @__PURE__ */ mergeAll(layer7, layer9, layer11, layer13));
-// ../../../../node_modules/.bun/@dual-os+sdk@0.8.1+a827849ded09603e/node_modules/@dual-os/sdk/dist/Runner.js
+// ../../../../node_modules/.bun/@dual-os+sdk@0.9.0+a827849ded09603e/node_modules/@dual-os/sdk/dist/Runner.js
 var guestOAuth = pipe(oauth2TokenRefresherLayer, provideMerge(layer3), provide(layer(fromUnknown({}))));
 function initializationError(cause) {
   if (is(PluginExecutionError)(cause))
@@ -5656,116 +5461,77 @@ function initializationError(cause) {
     }))) || "No error details returned by the plugin."
   });
 }
-pipe(gen(function* () {
-  const guestServices = yield* context();
-  const scope = yield* Scope;
-  const runtimeScope = yield* fork(scope, "sequential");
-  const failed = yield* make();
-  const invocations = yield* make14();
-  const stdio = yield* Stdio;
-  const args = yield* decodeUnknownEffect(Tuple([
-    NonEmptyString,
-    NonEmptyString,
-    Literals(["inspect", "execute"]),
-    NonEmptyString
-  ]))(yield* stdio.args);
-  const load = yield* cached(forkIn(gen(function* () {
-    const plugin = (yield* decodeUnknownEffect(Record(String3, Unknown))(yield* tryPromise({
-      try: () => import(args[0]),
-      catch: initializationError
-    })))[args[1]];
-    if (!isPlugin(plugin))
-      return yield* PluginExecutionError.make({
-        category: "protocol",
-        message: "The configured export is not an integration plugin"
-      });
-    yield* try_2({
-      try: () => make6(plugin.identifier),
-      catch: initializationError
-    });
-    return {
-      plugin,
-      runtime: yield* cached(forkIn(pipe(buildWithScope(pipe(toLayer(fromPlugin(plugin, args[3])), provideMerge(mergeAll(filesUnavailable, layer2, guestOAuth))), runtimeScope), provideContext(makeUnsafe(guestServices.mapUnsafe))), runtimeScope))
-    };
-  }), runtimeScope));
-  const execute$1 = fnUntraced(function* (request) {
-    return yield* pipe(gen(function* () {
-      const { plugin, runtime } = yield* join2(yield* load);
-      if (request.identity.pluginKey !== plugin.identifier && !(args[2] === "inspect" && ("_tag" in request) && request._tag === "extract"))
-        return yield* PluginExecutionError.make({
-          category: "protocol",
-          message: "Plugin identity does not match the request"
-        });
-      if (request.identity.pluginVersion !== args[3])
+var Options = Struct({
+  entrypoint: NonEmptyString,
+  exportName: NonEmptyString,
+  mode: Literals(["inspect", "execute"]),
+  version: NonEmptyString
+});
+var runtime = make14(mergeAll(layer14, layer4));
+function load(input) {
+  return runtime.runPromise(gen(function* () {
+    const options = yield* decodeUnknownEffect(Options)(input);
+    const guestServices = yield* context();
+    const scope = yield* make("sequential");
+    const loaded = yield* cached(forkIn(gen(function* () {
+      const plugin = (yield* decodeUnknownEffect(Record(String3, Unknown))(yield* tryPromise({
+        try: () => import(options.entrypoint),
+        catch: initializationError
+      })))[options.exportName];
+      if (!isPlugin(plugin))
         return yield* PluginExecutionError.make({
           category: "protocol",
-          message: "Plugin release does not match the request"
+          message: "The configured export is not an integration plugin"
         });
-      if ("_tag" in request && request._tag === "extract")
-        return {
-          _tag: "success",
-          identity: request.identity,
-          value: yield* decodeEffect(fromJsonString(Json))(yield* encodeEffect(fromJsonString(Unknown))(materializePlugin(plugin, { version: request.identity.pluginVersion })))
-        };
-      return yield* pipe(execute3(request), provideContext(yield* join2(yield* runtime)));
-    }), catchCauseIf((cause) => !hasInterrupts(cause), (cause) => args[2] === "inspect" ? fail5(initializationError(squash(cause))) : succeed4({
-      _tag: "failure",
-      identity: request.identity,
-      error: {
-        category: "initialization",
-        code: "PluginInitializationFailed",
-        message: "Cannot initialize the installed plugin",
-        retryable: false
-      }
-    })), mapError2(initializationError));
-  });
-  yield* raceFirst(pipe(ipcMessages(process), runForEach(fnUntraced(function* (message) {
-    const input = yield* decodeInput(message);
-    const key = yield* encodeEffect(fromJsonString(Identity))(input.identity);
-    if ("_tag" in input && input._tag === "cancel") {
-      const fiber = getOrUndefined(yield* get5(invocations, key));
-      if (fiber !== undefined)
-        yield* pipe(interrupt2(fiber), forkIn(scope));
-      return;
-    }
-    if ((yield* has3(invocations, key)) || (yield* size2(invocations)) >= 16)
-      return yield* PluginExecutionError.make({
-        category: "protocol",
-        message: "Plugin invocation is duplicate or exceeds concurrency"
+      yield* try_2({
+        try: () => make6(plugin.identifier),
+        catch: initializationError
       });
-    const fiber = yield* run3(invocations, key, scoped(execute$1(input)));
-    yield* pipe(gen(function* () {
-      const exit = yield* await_(fiber);
-      const send = fnUntraced(function* (output) {
-        const encoded = yield* encodeOutput(output, responseLimit(input));
-        if (args[2] !== "inspect")
-          return yield* sendIpc(process, encoded);
-        yield* callback((resume) => {
-          if (process.send === undefined) {
-            resume(fail5(initializationError("Plugin IPC channel is closed")));
-            return;
-          }
-          process.send(encoded, (error) => {
-            if (error !== null)
-              resume(fail5(initializationError(error)));
-            else
-              resume(void_2);
+      return {
+        plugin,
+        services: yield* cached(forkIn(pipe(buildWithScope(pipe(toLayer(fromPlugin(plugin, options.version)), provideMerge(mergeAll(filesUnavailable, layer2, guestOAuth))), scope), provideContext(makeUnsafe(guestServices.mapUnsafe))), scope))
+      };
+    }), scope));
+    const run = fnUntraced(function* (request) {
+      return yield* pipe(gen(function* () {
+        const { plugin, services } = yield* join2(yield* loaded);
+        if (request.identity.pluginKey !== plugin.identifier && !(options.mode === "inspect" && ("_tag" in request) && request._tag === "extract"))
+          return yield* PluginExecutionError.make({
+            category: "protocol",
+            message: "Plugin identity does not match the request"
           });
-        });
-        if (process.connected)
-          process.disconnect();
-      });
-      if (isSuccess2(exit))
-        return yield* send(exit.value);
-      if (every(exit.cause.reasons, isInterruptReason))
-        return yield* send({
-          _tag: "interrupted",
-          identity: input.identity
-        });
-      return yield* initializationError(squash(exit.cause));
-    }), catchCause((cause) => fail4(failed, initializationError(squash(cause)))), forkIn(scope));
-  })), mapError2(initializationError)), _await(failed));
-}), scoped, provide2([layer14, layer4]), runMain2({ disableErrorReporting: process.argv[4] !== "inspect" }));
+        if (request.identity.pluginVersion !== options.version)
+          return yield* PluginExecutionError.make({
+            category: "protocol",
+            message: "Plugin release does not match the request"
+          });
+        if ("_tag" in request && request._tag === "extract")
+          return {
+            _tag: "success",
+            identity: request.identity,
+            value: yield* decodeEffect(fromJsonString(Json))(yield* encodeEffect(fromJsonString(Unknown))(materializePlugin(plugin, { version: request.identity.pluginVersion })))
+          };
+        return yield* pipe(execute3(request), provideContext(yield* join2(yield* services)));
+      }), catchCauseIf((cause) => !hasInterrupts(cause), (cause) => options.mode === "inspect" ? fail5(initializationError(squash(cause))) : succeed5({
+        _tag: "failure",
+        identity: request.identity,
+        error: {
+          category: "initialization",
+          code: "PluginInitializationFailed",
+          message: "Cannot initialize the installed plugin",
+          retryable: false
+        }
+      })));
+    });
+    return { execute: (message, signal) => runtime.runPromise(pipe(gen(function* () {
+      const request = yield* decodeInput(message);
+      return yield* encodeOutput(yield* scoped(run(request)), responseLimit(request));
+    }), mapError2(initializationError)), { signal }) };
+  }));
+}
+export {
+  load
+};
 
-//# debugId=E3DAC05DF310E15464756E2164756E21
+//# debugId=F140CDA449712B2164756E2164756E21
 //# sourceMappingURL=Runner.js.map