diff --git a/package-lock.json b/package-lock.json
index cafa31c..802216b 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -2230,7 +2230,7 @@
     "node_modules/@web-applets/sdk": {
       "version": "0.2.6",
       "resolved": "https://gitpkg.vercel.app/unternet-co/web-applets/sdk?tokono.ma/experiment&scripts.postinstall=npm%20i%20%40types%2Fnode%20%26%26%20npx%20tsc",
-      "integrity": "sha512-6fDpl977RqV7zMfKDPrGEaJs2nX2cpLERFv6mC4pdpw2PwdBb1rqADitBRlEIquLUakga0pCfqJFSHqfRRJMOw==",
+      "integrity": "sha512-cIJ5viAtAKbbeB0izJ9VTXVDr9xsxAiGWMlhDZd1F9iHdGMk7j0cO8Q03wKxidVx5d/1kijHP07CDA7fygccEA==",
       "hasInstallScript": true,
       "license": "MIT"
     },
diff --git a/src/pages/configurator/input/_applet.astro b/src/pages/configurator/input/_applet.astro
index 4b871fd..d32a871 100644
--- a/src/pages/configurator/input/_applet.astro
+++ b/src/pages/configurator/input/_applet.astro
@@ -33,132 +33,40 @@
 
 <script>
   import type { Applet } from "@web-applets/sdk";
-  import * as URI from "uri-js";
 
-  import type { Consult, GroupConsult, Track } from "@applets/core/types.d.ts";
-  import type { Actions } from "@scripts/configurator/input/worker";
+  import type { Tasks } from "@scripts/configurator/input/worker";
   import type { Scheme } from "@scripts/configurator/input/types";
   import { CONNECTIONS } from "@scripts/configurator/input/constants";
   import { applet, register } from "@scripts/applet/common";
-  import { endpoint, groupTracksPerScheme, transfer } from "@scripts/common";
+  import { endpoint, transfer } from "@scripts/common";
   import manifest from "./_manifest.json";
 
   ////////////////////////////////////////////
   // SETUP
   ////////////////////////////////////////////
-  const worker = endpoint<Actions>(
+  const worker = endpoint<Tasks>(
     new SharedWorker(new URL("../../../scripts/configurator/input/worker", import.meta.url), {
       type: "module",
       name: manifest.name,
     }).port,
   );
 
-  // Register applet
-  const context = register();
+  // Register applet + worker
+  const context = register({ worker });
 
   ////////////////////////////////////////////
   // CONNECTIONS
-  ////////////////////////////////////////////// Applet connections
-  const connections: Record<Scheme, Promise<Applet> | undefined> = {
-    "file+local": undefined,
-    opensubsonic: undefined,
-    s3: undefined,
-  };
-
-  async function connection(scheme: Scheme) {
-    connections[scheme] = connections[scheme] ?? applet(CONNECTIONS[scheme]);
-    return connections[scheme];
-  }
-
-  function isSupportedScheme(scheme: string): scheme is Scheme {
-    return !!CONNECTIONS[scheme as Scheme];
-  }
-
-  ////////////////////////////////////////////
-  // ACTIONS
   ////////////////////////////////////////////
-  const consult = async (fileUriOrScheme: string): Promise<Consult> => {
-    const scheme = fileUriOrScheme.includes(":")
-      ? URI.parse(fileUriOrScheme).scheme || fileUriOrScheme
-      : fileUriOrScheme;
-
-    if (!isSupportedScheme(scheme)) {
-      return { supported: false, reason: "Unsupported scheme" };
-    }
-
-    const conn = await connection(scheme);
-    return await conn.sendAction<Consult>("consult", fileUriOrScheme, {
-      timeoutDuration: 60000 * 5,
-    });
-  };
-
-  const contextualize = async (tracks: Track[]) => {
-    const groups = await worker.groupTracks(transfer(tracks));
-    const promises = Object.entries(groups).map(
-      async ([scheme, tracksGroup]: [string, Track[]]) => {
-        if (!isSupportedScheme(scheme) || tracksGroup.length === 0) return;
-        const conn = await connection(scheme);
-        await conn.sendAction("contextualize", tracksGroup, { timeoutDuration: 60000 * 5 });
-      },
-    );
-
-    await Promise.all(promises);
+  const connections: Record<Scheme, Promise<Applet>> = {
+    "file+local": applet(CONNECTIONS["file+local"], { context: self }),
+    opensubsonic: applet(CONNECTIONS.opensubsonic, { context: self }),
+    s3: applet(CONNECTIONS.s3, { context: self }),
   };
 
-  const groupConsult = async (tracks: Track[]) => {
-    const groups = groupTracksPerScheme(tracks);
-    const consultations = await Promise.all(
-      Object.keys(groups).map(async (scheme) => {
-        if (!isSupportedScheme(scheme)) {
-          return { available: false, reason: "Unsupported scheme" };
-        }
-
-        const conn = await connection(scheme);
-        return await conn.sendAction("groupConsult", groups[scheme] || [], {
-          timeoutDuration: 60000 * 5,
-        });
-      }),
-    );
-
-    return consultations.reduce((acc: GroupConsult, c: GroupConsult) => {
-      return { ...acc, ...c };
-    }, {});
-  };
-
-  const list = async (cachedTracks: Track[] = []) => {
-    const groups = await worker.groupTracks(transfer(cachedTracks));
-
-    const promises = Object.entries(groups).map(
-      async ([scheme, cachedTracksGroup]: [string, Track[]]) => {
-        if (!isSupportedScheme(scheme)) return cachedTracksGroup;
-        const conn = await connection(scheme);
-        return await conn.sendAction("list", cachedTracksGroup, {
-          timeoutDuration: 60000 * 60 * 24,
-        });
-      },
-    );
-
-    const nested = await Promise.all(promises);
-    const tracks = nested.flat(1);
-
-    return tracks;
-  };
-
-  const resolve = async (args: { method: string; uri: string }) => {
-    const scheme = args.uri.split(":", 1)[0];
-    if (!isSupportedScheme(scheme)) return undefined;
-
-    try {
-      const conn = await connection(scheme);
-      return await conn.sendAction("resolve", args, { timeoutDuration: 60000 * 5 });
-    } catch (err) {
-      console.error(`[configuration/input] Resolve error for scheme '${scheme}'.`, err);
-    }
-  };
-
-  context.setActionHandler("consult", consult);
-  context.setActionHandler("contextualize", contextualize);
-  context.setActionHandler("groupConsult", groupConsult);
-  context.setActionHandler("list", list);
-  context.setActionHandler("resolve", resolve);
+  // Pass worker message ports to configurator worker
+  Object.entries(connections).forEach(([scheme, promise]) => {
+    promise.then((conn) => {
+      return worker.manageInputWorker(scheme as Scheme, transfer(conn.ports.worker));
+    });
+  });
 </script>
diff --git a/src/pages/core/types.d.ts b/src/pages/core/types.d.ts
index 508e6da..afbd528 100644
--- a/src/pages/core/types.d.ts
+++ b/src/pages/core/types.d.ts
@@ -16,6 +16,14 @@ export type ConsultGrouping =
 
 export type GroupConsult = Record<string, ConsultGrouping>;
 
+export interface InputWorkerTasks {
+  consult(fileUriOrScheme: string): Promise<Consult>;
+  contextualize(tracks: Track[]): Promise<void>;
+  groupConsult(tracks: Track[]): Promise<GroupConsult>;
+  list(cachedTracks: Track[] = []): Promise<Track[]>;
+  resolve({ method, uri }: { method: string; uri: string }): Promise<ResolvedUri>;
+}
+
 /* OUTPUT */
 
 export interface Output<S = TrackStats, T = TrackTags> {
diff --git a/src/pages/input/native-fs/_applet.astro b/src/pages/input/native-fs/_applet.astro
index 8a0ae0c..a2e2f5c 100644
--- a/src/pages/input/native-fs/_applet.astro
+++ b/src/pages/input/native-fs/_applet.astro
@@ -16,7 +16,7 @@
 </main>
 
 <script>
-  import type { Actions } from "@scripts/input/native-fs/worker";
+  import type { Tasks } from "@scripts/input/native-fs/worker";
   import type { Track } from "@applets/core/types.d.ts";
   import { register } from "@scripts/applet/common";
   import { endpoint, inIframe, SharedWorker, transfer } from "@scripts/common";
@@ -26,7 +26,7 @@
   ////////////////////////////////////////////
   // SETUP
   ////////////////////////////////////////////
-  const worker = endpoint<Actions>(
+  const worker = endpoint<Tasks>(
     new SharedWorker(new URL("../../../scripts/input/native-fs/worker", import.meta.url), {
       type: "module",
       name: manifest.name,
@@ -34,7 +34,7 @@
   );
 
   // Register applet
-  const context = register();
+  const context = register({ worker });
 
   ////////////////////////////////////////////
   // ACTIONS
diff --git a/src/pages/input/opensubsonic/_applet.astro b/src/pages/input/opensubsonic/_applet.astro
index 554baf1..8ecd776 100644
--- a/src/pages/input/opensubsonic/_applet.astro
+++ b/src/pages/input/opensubsonic/_applet.astro
@@ -18,7 +18,7 @@
 </main>
 
 <script>
-  import type { Actions } from "@scripts/input/opensubsonic/worker";
+  import type { Tasks } from "@scripts/input/opensubsonic/worker";
   import type { Track } from "@applets/core/types.d.ts";
   import { register } from "@scripts/applet/common";
   import { endpoint, inIframe, SharedWorker, transfer } from "@scripts/common";
@@ -27,7 +27,7 @@
   ////////////////////////////////////////////
   // SETUP
   ////////////////////////////////////////////
-  const worker = endpoint<Actions>(
+  const worker = endpoint<Tasks>(
     new SharedWorker(new URL("../../../scripts/input/opensubsonic/worker", import.meta.url), {
       type: "module",
       name: manifest.name,
@@ -35,7 +35,7 @@
   );
 
   // Register applet
-  const context = register();
+  const context = register({ worker });
 
   ////////////////////////////////////////////
   // ACTIONS
diff --git a/src/pages/input/s3/_applet.astro b/src/pages/input/s3/_applet.astro
index 358f3bb..46c3e48 100644
--- a/src/pages/input/s3/_applet.astro
+++ b/src/pages/input/s3/_applet.astro
@@ -37,8 +37,7 @@
 </style>
 
 <script>
-  import type { Actions } from "@scripts/input/s3/worker";
-
+  import type { Tasks } from "@scripts/input/s3/worker";
   import type { Track } from "@applets/core/types.d.ts";
   import { register } from "@scripts/applet/common";
   import { endpoint, inIframe, SharedWorker, transfer } from "@scripts/common";
@@ -47,7 +46,7 @@
   ////////////////////////////////////////////
   // SETUP
   ////////////////////////////////////////////
-  const worker = endpoint<Actions>(
+  const worker = endpoint<Tasks>(
     new SharedWorker(new URL("../../../scripts/input/s3/worker", import.meta.url), {
       type: "module",
       name: manifest.name,
@@ -55,7 +54,7 @@
   );
 
   // Register applet
-  const context = register();
+  const context = register({ worker });
 
   ////////////////////////////////////////////
   // ACTIONS
diff --git a/src/pages/orchestrator/input-cache/_applet.astro b/src/pages/orchestrator/input-cache/_applet.astro
index 6629845..a6412c2 100644
--- a/src/pages/orchestrator/input-cache/_applet.astro
+++ b/src/pages/orchestrator/input-cache/_applet.astro
@@ -24,11 +24,11 @@
   };
 
   // Start processing once settled and tracks are loaded
-  // context
-  //   .settled()
-  //   .then(() => configurator.output)
-  //   .then((output) => wait(output, (d) => d?.tracks.state === "loaded"))
-  //   .then(() => (context.isMainInstance() ? process() : undefined));
+  context
+    .settled()
+    .then(() => configurator.output)
+    .then((output) => wait(output, (d) => d?.tracks.state === "loaded"))
+    .then(() => (context.isMainInstance() ? process() : undefined));
 
   ////////////////////////////////////////////
   // ACTIONS
@@ -47,12 +47,14 @@
 
     await input.sendAction("contextualize", cachedTracks, {
       timeoutDuration: 60000 * 5,
+      worker: true,
     });
 
     console.log("CONTEXTUALIZED");
 
     const tracks = await input.sendAction<Track[]>("list", cachedTracks, {
       timeoutDuration: 60000 * 60 * 24,
+      worker: true,
     });
 
     console.log("LISTED", tracks);
@@ -69,6 +71,7 @@
           { method: "GET", uri: track.uri },
           {
             timeoutDuration: 60000 * 5,
+            worker: true,
           },
         );
 
@@ -77,6 +80,7 @@
           { method: "HEAD", uri: track.uri },
           {
             timeoutDuration: 60000 * 5,
+            worker: true,
           },
         );
 
diff --git a/src/pages/orchestrator/queue-tracks/_applet.astro b/src/pages/orchestrator/queue-tracks/_applet.astro
index bb0b4cf..cd14d2b 100644
--- a/src/pages/orchestrator/queue-tracks/_applet.astro
+++ b/src/pages/orchestrator/queue-tracks/_applet.astro
@@ -37,7 +37,7 @@
         const groups = await configurator.input.sendAction<GroupConsult>(
           "groupConsult",
           configurator.output.data.tracks.collection,
-          { timeoutDuration: 60000 * 5 },
+          { timeoutDuration: 60000 * 5, worker: true },
         );
 
         // Available tracks
diff --git a/src/scripts/applet/common.ts b/src/scripts/applet/common.ts
index 3d5dd6f..366baa3 100644
--- a/src/scripts/applet/common.ts
+++ b/src/scripts/applet/common.ts
@@ -7,7 +7,7 @@ import { effect, isSignal, type Signal, signal } from "spellcaster/spellcaster.j
 import QS from "query-string";
 
 import type { ResolvedUri } from "@applets/core/types";
-import { transfer, type WorkerActions } from "@scripts/common";
+import { transfer, type WorkerTasks } from "@scripts/common";
 
 ////////////////////////////////////////////
 // 🪟 Applet connecting
@@ -17,6 +17,7 @@ export async function applet<D>(
   opts: {
     addSlashSuffix?: boolean;
     container?: HTMLElement | Element;
+    context?: Window;
     frameId?: string;
     groupId?: string;
     setHeight?: boolean;
@@ -40,7 +41,7 @@ export async function applet<D>(
     src = QS.stringifyUrl({ url: src, query });
   }
 
-  const context = self.top || self.parent;
+  const context = opts.context || self.top || self.parent;
   const existingFrame: HTMLIFrameElement | null = context.document.querySelector(`[src="${src}"]`);
 
   let frame;
@@ -109,7 +110,7 @@ export type BroadcastedApplet<T> = {
 };
 
 export function register<DataType = any>(
-  options: { worker?: Comlink.Remote<WorkerActions> } = {},
+  options: { worker?: Comlink.Remote<WorkerTasks> } = {},
 ): BroadcastedApplet<DataType> {
   const url = new URL(location.href);
   const scope = applets.register<DataType>();
@@ -288,7 +289,7 @@ export function register<DataType = any>(
   if (options.worker !== undefined)
     context.scope.onworkerport = (event) => {
       if (!event.port) return;
-      options.worker?.perform(transfer(event.port));
+      options.worker?.listenForActions(transfer(event.port));
     };
 
   return context;
@@ -335,6 +336,7 @@ export async function inputUrl(input: Applet, uri: string, method = "GET") {
     },
     {
       timeoutDuration: 60000 * 5,
+      worker: true,
     },
   );
 }
diff --git a/src/scripts/common.ts b/src/scripts/common.ts
index 78b746e..55ee013 100644
--- a/src/scripts/common.ts
+++ b/src/scripts/common.ts
@@ -12,8 +12,8 @@ export const SharedWorker = globalThis.SharedWorker;
 // 🌳
 ////////////////////////////////////////////
 
-export type WorkerActions = {
-  perform: ReturnType<typeof handleWorkerActions>;
+export type WorkerTasks = {
+  listenForActions: ReturnType<typeof handleWorkerActions>;
 };
 
 ////////////////////////////////////////////
@@ -59,26 +59,26 @@ export function comparable(value: unknown) {
   return xxh32(JSON.stringify(value));
 }
 
-export function endpoint<T extends Record<string, any> = WorkerActions>(ini: Comlink.Endpoint) {
+export function endpoint<T extends Record<string, any> = WorkerTasks>(ini: Comlink.Endpoint) {
   const e = Comlink.wrap<T>(ini);
   if ("start" in ini && typeof ini.start === "function") ini.start();
   return e;
 }
 
-export function expose<A extends Record<string, any>>(actions: A): A {
+export function expose<A extends Record<string, any>>(tasks: A): A {
   if (globalThis.SharedWorkerGlobalScope && self instanceof SharedWorkerGlobalScope) {
     self.onconnect = (event: MessageEvent) => {
       const port = event.ports[0];
-      Comlink.expose(actions, port);
+      Comlink.expose(tasks, port);
       port.start();
     };
 
     (self as any).connected = true;
   } else {
-    Comlink.expose(actions, self);
+    Comlink.expose(tasks, self);
   }
 
-  return actions;
+  return tasks;
 }
 
 export function groupTracksPerScheme(
@@ -107,9 +107,13 @@ export function jsonEncode<T>(a: T): Uint8Array {
   return new TextEncoder().encode(JSON.stringify(a));
 }
 
-export function provide<A extends Record<string, any>>(actions: A) {
-  return expose({
-    perform: handleWorkerActions(actions),
+export function provide<A extends Record<string, any>, B extends Record<string, any>>(
+  actions: A,
+  tasks: B = {} as B,
+) {
+  return expose<WorkerTasks & B>({
+    listenForActions: handleWorkerActions(actions),
+    ...tasks,
   });
 }
 
@@ -154,6 +158,8 @@ function handleWorkerActions<A extends Record<string, any>>(actions: A) {
   }
 
   return (port: MessagePort) => {
+    Comlink.expose(actions, port);
+
     port.onmessage = async (message) => {
       switch (message.data?.type) {
         case "action":
diff --git a/src/scripts/configurator/input/common.ts b/src/scripts/configurator/input/common.ts
new file mode 100644
index 0000000..0c45efe
--- /dev/null
+++ b/src/scripts/configurator/input/common.ts
@@ -0,0 +1,6 @@
+import { CONNECTIONS } from "./constants";
+import type { Scheme } from "./types";
+
+export function isSupportedScheme(scheme: string): scheme is Scheme {
+  return !!CONNECTIONS[scheme as Scheme];
+}
diff --git a/src/scripts/configurator/input/worker.ts b/src/scripts/configurator/input/worker.ts
index 37ca93b..1df0eae 100644
--- a/src/scripts/configurator/input/worker.ts
+++ b/src/scripts/configurator/input/worker.ts
@@ -1,17 +1,142 @@
-import { expose, groupTracksPerScheme, transfer } from "@scripts/common";
+import * as URI from "uri-js";
+
+import type {
+  Consult,
+  ConsultGrouping,
+  GroupConsult,
+  InputWorkerTasks,
+  Track,
+} from "@applets/core/types";
+import type { Scheme } from "./types";
 import { CONNECTIONS } from "./constants";
-import type { Track } from "@applets/core/types";
+import { endpoint, groupTracksPerScheme, provide, transfer } from "@scripts/common";
+import { isSupportedScheme } from "./common";
+import type { Remote } from "comlink";
+
+////////////////////////////////////////////
+// TASKS
+////////////////////////////////////////////
+const tasks = provide(
+  {
+    consult,
+    contextualize,
+    groupConsult,
+    list,
+    resolve,
+  },
+  {
+    manageInputWorker,
+  },
+);
+
+export type Tasks = typeof tasks;
+
+////////////////////////////////////////////
+// CONNECTIONS
+////////////////////////////////////////////
+const connections: Record<
+  Scheme,
+  {
+    promise: Promise<Remote<InputWorkerTasks>>;
+    resolve: (value: Remote<InputWorkerTasks>) => void;
+    reject: () => void;
+  }
+> = {
+  "file+local": Promise.withResolvers(),
+  opensubsonic: Promise.withResolvers(),
+  s3: Promise.withResolvers(),
+};
+
+function manageInputWorker(scheme: Scheme, port: MessagePort) {
+  // TODO: Not sure what happens here when it's already resolved.
+  //       I guess ideally the connections record should always
+  //       provide the latest incoming value from here.
+  connections[scheme].resolve(endpoint<InputWorkerTasks>(port));
+}
 
 ////////////////////////////////////////////
 // ACTIONS
 ////////////////////////////////////////////
-const actions = expose({
-  groupTracks,
-});
 
-export type Actions = typeof actions;
+async function consult(fileUriOrScheme: string): Promise<Consult> {
+  const scheme = fileUriOrScheme.includes(":")
+    ? URI.parse(fileUriOrScheme).scheme || fileUriOrScheme
+    : fileUriOrScheme;
+
+  if (!isSupportedScheme(scheme)) {
+    return { supported: false, reason: "Unsupported scheme" };
+  }
+
+  const conn = await connections[scheme].promise;
+  return conn.consult(fileUriOrScheme);
+}
+
+async function contextualize(tracks: Track[]) {
+  const groups = groupTracks(tracks);
+  const promises = Object.entries(groups).map(async ([scheme, tracksGroup]: [string, Track[]]) => {
+    if (!isSupportedScheme(scheme) || tracksGroup.length === 0) return;
+    const conn = await connections[scheme].promise;
+    await conn.contextualize(tracksGroup);
+  });
+
+  await Promise.all(promises);
+}
+
+async function groupConsult(tracks: Track[]) {
+  const groups = groupTracksPerScheme(tracks);
 
-// Actions
+  const consultations: GroupConsult[] = await Promise.all(
+    Object.keys(groups).map(async (scheme) => {
+      if (!isSupportedScheme(scheme)) {
+        return {
+          [scheme]: { available: false, reason: "Unsupported scheme" },
+        };
+      }
+
+      const conn = await connections[scheme].promise;
+      const result = await conn.groupConsult(groups[scheme] || []);
+
+      return result;
+    }),
+  );
+
+  return consultations.reduce((acc: GroupConsult, c: GroupConsult) => {
+    return { ...acc, ...c };
+  }, {});
+}
+
+async function list(cachedTracks: Track[] = []) {
+  const groups = groupTracks(cachedTracks);
+
+  const promises = Object.entries(groups).map(
+    async ([scheme, cachedTracksGroup]: [string, Track[]]) => {
+      if (!isSupportedScheme(scheme)) return cachedTracksGroup;
+      const conn = await connections[scheme].promise;
+      return conn.list(cachedTracksGroup);
+    },
+  );
+
+  const nested = await Promise.all(promises);
+  const tracks = nested.flat(1);
+
+  return tracks;
+}
+
+async function resolve(args: { method: string; uri: string }) {
+  const scheme = args.uri.split(":", 1)[0];
+  if (!isSupportedScheme(scheme)) return undefined;
+
+  try {
+    const conn = await connections[scheme].promise;
+    return await conn.resolve(args);
+  } catch (err) {
+    console.error(`[configuration/input] Resolve error for scheme '${scheme}'.`, err);
+  }
+}
+
+////////////////////////////////////////////
+// 🛠️
+////////////////////////////////////////////
 
 function groupTracks(tracks: Track[]) {
   const grouped = groupTracksPerScheme(
@@ -23,5 +148,5 @@ function groupTracks(tracks: Track[]) {
     ),
   );
 
-  return transfer(grouped);
+  return grouped;
 }
diff --git a/src/scripts/input/native-fs/worker.ts b/src/scripts/input/native-fs/worker.ts
index 00f6ea0..f60770e 100644
--- a/src/scripts/input/native-fs/worker.ts
+++ b/src/scripts/input/native-fs/worker.ts
@@ -9,22 +9,25 @@ import {
   recursiveList,
   trackHandleId,
 } from "./common";
-import { expose, transfer } from "@scripts/common";
+import { expose, provide, transfer } from "@scripts/common";
 
 ////////////////////////////////////////////
-// ACTIONS
+// TASKS
 ////////////////////////////////////////////
-const actions = expose({
+const actions = {
   consult,
   contextualize,
   groupConsult,
   list,
   resolve,
-});
+};
+
+const tasks = provide(actions, actions);
 
 export type Actions = typeof actions;
+export type Tasks = typeof tasks;
 
-// Actions
+// Tasks
 
 export async function consult(fileUriOrScheme: string): Promise<Consult> {
   if (!self.FileSystemDirectoryHandle) {
diff --git a/src/scripts/input/opensubsonic/common.ts b/src/scripts/input/opensubsonic/common.ts
index 1f585b2..7dcbd0a 100644
--- a/src/scripts/input/opensubsonic/common.ts
+++ b/src/scripts/input/opensubsonic/common.ts
@@ -138,6 +138,9 @@ export function serverId(server: Server) {
     query: `tls=${server.tls ? "t" : "f"}`,
   };
 
-  if (server.apiKey) return URI.serialize({ ...parts, userinfo: server.apiKey });
-  return URI.serialize({ ...parts, userinfo: `${server.username}:${server.password}` });
+  const uri = server.apiKey
+    ? URI.serialize({ ...parts, userinfo: server.apiKey })
+    : URI.serialize({ ...parts, userinfo: `${server.username}:${server.password}` });
+
+  return btoa(uri);
 }
diff --git a/src/scripts/input/opensubsonic/worker.ts b/src/scripts/input/opensubsonic/worker.ts
index e064b05..7d2360d 100644
--- a/src/scripts/input/opensubsonic/worker.ts
+++ b/src/scripts/input/opensubsonic/worker.ts
@@ -14,22 +14,25 @@ import {
   serverId,
   serversFromTracks,
 } from "./common.ts";
-import { expose, transfer } from "@scripts/common.ts";
+import { expose, provide, transfer } from "@scripts/common.ts";
 
 ////////////////////////////////////////////
-// ACTIONS
+// TASKS
 ////////////////////////////////////////////
-const actions = expose({
+const actions = {
   consult,
   contextualize,
   groupConsult,
   list,
   resolve,
-});
+};
+
+const tasks = provide(actions, actions);
 
 export type Actions = typeof actions;
+export type Tasks = typeof tasks;
 
-// Actions
+// Tasks
 
 async function consult(fileUriOrScheme: string): Promise<Consult> {
   if (!fileUriOrScheme.includes(":")) return { supported: true, consult: "undetermined" };
diff --git a/src/scripts/input/s3/worker.ts b/src/scripts/input/s3/worker.ts
index 00818e5..a1c3d90 100644
--- a/src/scripts/input/s3/worker.ts
+++ b/src/scripts/input/s3/worker.ts
@@ -10,23 +10,26 @@ import {
   loadBuckets,
   parseURI,
 } from "./common";
-import { expose, transfer } from "@scripts/common";
+import { expose, provide, transfer } from "@scripts/common";
 import { SCHEME } from "./constants";
 
 ////////////////////////////////////////////
-// ACTIONS
+// TASKS
 ////////////////////////////////////////////
-const actions = expose({
+const actions = {
   consult,
   contextualize,
   groupConsult,
   list,
   resolve,
-});
+};
+
+const tasks = provide(actions, actions);
 
 export type Actions = typeof actions;
+export type Tasks = typeof tasks;
 
-// Actions
+// Tasks
 
 async function consult(fileUriOrScheme: string): Promise<Consult> {
   if (!fileUriOrScheme.includes(":")) return { supported: true, consult: "undetermined" };