effect-web-midi 0.1.4 → 0.1.6

package/README.md

@@ -13,29 +13,24 @@ Huge thanks to [Web MIDI spec](https://www.w3.org/TR/webmidi/)!
 import { Atom, Result, useAtom, useAtomValue } from '@effect-atom/atom-react';
 import { styled } from '@linaria/react';
 import * as Cause from 'effect/Cause';
-import * as Chunk from 'effect/Chunk';
 import * as Console from 'effect/Console';
 import * as Effect from 'effect/Effect';
 import { flow, pipe } from 'effect/Function';
+import * as Record from 'effect/Record';
 import * as Stream from 'effect/Stream';
-import {
-  EMIDIAccess,
-  EMIDIInput,
-  EMIDIOutput,
-  Parsing,
-  Util,
-} from 'effect-web-midi';
-
-const nanoPadInputId1 = EMIDIInput.Id(
-  '1A0CE1F47C19C43DAEB93B9595F6E4BA822ED318FE8D8BF2750B66286B5BEC38'
-);
-const nanoPadInputId2 = EMIDIInput.Id(
-  'EF5E7457082713264B5DBD318651DA2134B6A34EB9F32BFD2C8E0B121508D10A'
+import * as EMIDIAccess from 'effect-web-midi/EMIDIAccess';
+import * as EMIDIInput from 'effect-web-midi/EMIDIInput';
+import * as EMIDIOutput from 'effect-web-midi/EMIDIOutput';
+import * as EMIDIPort from 'effect-web-midi/EMIDIPort';
+import * as Parsing from 'effect-web-midi/Parsing';
+import * as Util from 'effect-web-midi/Util';
+
+const nanoPadInputId = EMIDIInput.Id(
+  '380CB1F6BC0A21C5AAA0CDF95170A996937337454636CDDE223EEA6812283B07'
 );
-const nanoPadInputId = nanoPadInputId2;
 
 const nanoPadOutputId = EMIDIOutput.Id(
-  '380CB1F6BC0A21C5AAA0CDF95170A996937337454636CDDE223EEA6812283B07'
+  '045297AACE044DA224B59E92DBC0E874160B85D0D43BE505CBB053747F4AA90A'
 );
 
 const globalDataDumpRequest = new Uint8Array([
@@ -46,23 +41,94 @@ const globalDataDumpRequest = new Uint8Array([
   0x1f, 0x0e, 0x00, 0xf7,
 ]);
 
-const _MIDIDeviceConnectionEventsStringLog = EMIDIAccess.request().pipe(
+const _MIDIDeviceConnectionEventsStringLog = pipe(
+  // The lib supports both ways of working with access. You can either work with
+  // its instance directly, or provide it through DI. All of the functions have
+  // equivalents supporting both approaches. In this case we work with it directly
+  EMIDIAccess.request(),
+  //          ⬆️ Effect<
+  //               EMIDIAccess.EMIDIAccessInstance,
+  //               | AbortError
+  //               | UnderlyingSystemError
+  //               | MIDIAccessNotSupportedError
+  //               | MIDIAccessNotAllowedError,
+  //               never
+  //             >
   Effect.catchTag(
     'MIDIAccessNotSupportedError',
     flow(Console.log, Effect.andThen(Effect.never))
   ),
+  // notice that function below consumed access. It can consume access
+  // regardless if it's wrapped in effect or not. It also has both
+  // data-first and data-last signatures supported. Every function in this lib
+  // conforms that rule
   EMIDIAccess.makeAllPortsStateChangesStream(),
+  //          ⬆️ Stream<
+  //               {
+  //                 readonly _tag: "MIDIPortStateChange";
+  //                 readonly cameFrom: EMIDIAccess.EMIDIAccessInstance;
+  //                 readonly capturedAt: Date;
+  //                 readonly newState: {
+  //                   readonly ofDevice: MIDIPortDeviceState;
+  //                   readonly ofConnection: MIDIPortConnectionState;
+  //                 };
+  //                 readonly port: EMIDIOutput | EMIDIInput;
+  //               },
+  //               | AbortError
+  //               | UnderlyingSystemError
+  //               | MIDIAccessNotAllowedError,
+  //               never
+  //             >
+  // This is just a helper to render a list of objects to a string in nice-ish way
   Util.mapToGlidingStringLogOfLimitedEntriesCount(50, 'latestFirst', (_) => ({
     time: _.capturedAt.toISOString(),
     id: _.port.id.slice(-10),
     device: _.newState.ofDevice.padStart(12),
     connection: _.newState.ofConnection.padStart(7),
   }))
+  // ⬆️ Stream<
+  //      string,
+  //      | AbortError
+  //      | UnderlyingSystemError
+  //      | MIDIAccessNotAllowedError,
+  //      never
+  //    >
 );
 
 const MIDIMessageEventsStringLog = pipe(
+  // if the ID below turned out to be output's, it would cause defect (by design),
+  // because messages can only come from inputs. Notice that instead of demanding
+  // access from arguments, this particular method expects it to be provided in
+  // requirements.
   EMIDIInput.makeMessagesStreamById(nanoPadInputId),
+  //         ⬆️ Stream<
+  //              {
+  //                readonly _tag: "MIDIMessage";
+  //                readonly cameFrom: EMIDIInput;
+  //                readonly capturedAt: Date;
+  //                readonly midiMessage: Uint8Array<ArrayBuffer>;
+  //              },
+  //              PortNotFoundError,
+  //              EMIDIAccess
+  //            >
   Parsing.withParsedDataField,
+  //      ⬆️ Stream<
+  //           {
+  //             readonly _tag: "ParsedMIDIMessage";
+  //             readonly cameFrom: EMIDIInput;
+  //             readonly capturedAt: Date;
+  //             readonly midiMessage: | NoteRelease
+  //                                   | NotePress
+  //                                   | UnknownReply
+  //                                   | ControlChange
+  //                                   | TouchpadRelease
+  //                                   | PitchBendChange
+  //           },
+  //           PortNotFoundError,
+  //           EMIDIAccess
+  //         >
+  // function below adds new member to the midiMessage union inferred from
+  // ControlChange, PitchBendChange, and TouchpadRelease
   Parsing.withTouchpadPositionUpdates,
   Stream.filter(
     (a) =>
@@ -71,8 +137,9 @@ const MIDIMessageEventsStringLog = pipe(
       a.midiMessage._tag === 'Note Press' ||
       a.midiMessage._tag === 'Note Release'
   ),
+  // Just for the demo, show only select list of events
   Util.mapToGlidingStringLogOfLimitedEntriesCount(
-    5,
+    50,
     'latestFirst',
     (current) => ({
       time: current.capturedAt.toISOString(),
@@ -80,30 +147,65 @@ const MIDIMessageEventsStringLog = pipe(
       ...current.midiMessage,
     })
   ),
-  Stream.catchTag('PortNotFound', () =>
-    Stream.succeed(`KORG nanoPAD not found in the list of connected devices`)
+  // ⬆️ Stream<string, PortNotFoundError, EMIDIAccess>
+  Stream.catchTag('PortNotFound', (err) =>
+    Stream.fromEffect(
+      EMIDIPort.FullRecord.pipe(
+        //      ⬆️ Effect<
+        //           {
+        //             [id: EMIDIPort.Id<'input'>]: EMIDIPort<'input'>
+        //           } & {
+        //             [id: EMIDIPort.Id<'output'>]: EMIDIPort<'output'>
+        //           },
+        //           never,
+        //           EMIDIAccess.EMIDIAccess
+        //         >
+        Effect.map(
+          Record.reduce(
+            `Port with id=${err.portId} is not found. Currently available ports: \n`,
+            (acc, { type, version, name }, id) =>
+              acc + type.padEnd(7) + id + ' ' + version + ' ' + name + '\n'
+          )
+        ),
+        Effect.flatMap(Console.log),
+        Effect.andThen(
+          `KORG nanoPAD not found in the list of connected devices`
+        )
+      )
+    )
   ),
+  // ⬆️ Stream.Stream<string, never, EMIDIAccess>
   Stream.provideLayer(EMIDIAccess.layerSystemExclusiveSupported),
+  // ⬆️ Stream.Stream<
+  //   string,
+  //   | AbortError
+  //   | UnderlyingSystemError
+  //   | MIDIAccessNotSupportedError
+  //   | MIDIAccessNotAllowedError,
+  //   never
+  // >
   Stream.catchTag('MIDIAccessNotSupportedError', (e) =>
     Stream.succeed(e.cause.message)
   )
 );
 
 const dumpRequester = Atom.fn(() =>
+  // A particular example of methods flexibility. Here EMIDIAccess.send is a
+  // data-first signature and accepts EMIDIAccess wrapped by Effect
   EMIDIAccess.send(
     EMIDIAccess.request({ sysex: true }),
-    // ^ Effect.Effect<
-    //       EMIDIAccess.EMIDIAccessInstance,
-    //       | AbortError
-    //       | UnderlyingSystemError
-    //       | MIDIAccessNotAllowedError
-    //       | MIDIAccessNotSupportedError,
-    //       never
-    //   >
+    //          ⬆️ Effect.Effect<
+    //                 EMIDIAccess.EMIDIAccessInstance,
+    //                 | AbortError
+    //                 | UnderlyingSystemError
+    //                 | MIDIAccessNotAllowedError
+    //                 | MIDIAccessNotSupportedError,
+    //                 never
+    //             >
     nanoPadOutputId,
-    // ^ string & Brand<"MIDIPortId"> & Brand<"output">
+    // ⬆️ string & Brand<"MIDIPortId"> & Brand<"output">
     globalDataDumpRequest
-    // ^ Uint8Array<ArrayBuffer>
+    // ⬆️ Uint8Array<ArrayBuffer>
   )
 );
 
@@ -114,6 +216,7 @@ const textAtom = Atom.make(
 
 export default function Home() {
   const text = useAtomValue(textAtom);
+  console.log(text);
   const [, mutate] = useAtom(dumpRequester);
 
   return (
@@ -121,12 +224,10 @@ export default function Home() {
       <form
         onSubmit={(event) => {
           event.preventDefault();
-          console.log('hex', new FormData(event.target as any).get('hex'));
           mutate();
         }}
       >
-        <input type='text' name='hex' />
-        <input type='submit' value='send' />
+        <input type='submit' value='dump' />
       </form>
 
       {Result.match(text, {
@@ -134,10 +235,7 @@ export default function Home() {
           <>
             failure:
             <br />
-            {Cause.failures(_.cause).pipe(
-              Chunk.map((e) => e.message),
-              Chunk.join('\n')
-            )}
+            {Cause.pretty(_.cause)}
           </>
         ),
         onInitial: (e) => <>initial waiting: {e.waiting.toString()}</>,
@@ -151,3 +249,7 @@ const Wrapper = styled.div`
   color: wheat;
 `;
 ```
+
+<img width="1567" height="946" alt="Screenshot From 2025-12-29 01-46-34" src="https://github.com/user-attachments/assets/7411d393-0ef4-485a-954d-0d8d4e56a42e" />
+
+![photo_2025-11-17_22-00-08](https://github.com/user-attachments/assets/e45ead32-6675-4fed-aff3-aeb416ba8ead)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-web-midi",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "type": "module",
   "description": "Effect WEB MIDI",
   "license": "MIT",

package/src/EMIDIInput.ts

@@ -133,12 +133,12 @@ export {
   // openPortConnectionByPort,
 } from './internal/MIDIPortMethodCalls/openPortConnection/openPortConnectionByPort.ts'
 export {
-  openInputConnectionByPortIdAndAccess as openConnectionById,
+  openInputConnectionByPortIdAndAccess as openConnectionByIdAndAccess,
   // openOutputConnectionByPortIdAndAccess,
   // openPortConnectionByPortIdAndAccess,
 } from './internal/MIDIPortMethodCalls/openPortConnection/openPortConnectionByPortIdAndAccess.ts'
 export {
-  openInputConnectionByPortIdInContext as openConnectionByIdAndAccess,
+  openInputConnectionByPortIdInContext as openConnectionById,
   // openOutputConnectionByPortIdInContext,
   // openPortConnectionByPortIdInContext,
 } from './internal/MIDIPortMethodCalls/openPortConnection/openPortConnectionByPortIdInContext.ts'

package/src/internal/EMIDIAccess.ts

@@ -595,7 +595,7 @@ export const makeMessagesStreamByInputId = <
 
 // TODO: makeMessagesStreamByInputIdAndAccess
 export const makeMessagesStreamByInputIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 /**

package/src/internal/Parsing.ts

@@ -22,9 +22,13 @@ export const withParsedDataField = <
 ) =>
   Stream.map(self, ({ midiMessage, ...obj }) => ({
     ...obj,
+    _tag: 'ParsedMIDIMessage' as const,
     midiMessage: dataEntryParser(midiMessage),
   })) as Stream.Stream<
-    Omit<A, 'midiMessage'> & { readonly midiMessage: ParsedMIDIMessages },
+    Omit<A, 'midiMessage' | '_tag'> & {
+      readonly _tag: 'ParsedMIDIMessage'
+      readonly midiMessage: ParsedMIDIMessages
+    },
     E,
     R
   >

package/src/internal/makePortStateChangesStream/makePortStateChangesStreamByPortIdAndAccess.ts

@@ -1,14 +1,14 @@
 // TODO: makeInputStateChangesStreamByPortIdAndAccess
 export const makeInputStateChangesStreamByPortIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: makeOutputStateChangesStreamByPortIdAndAccess
 export const makeOutputStateChangesStreamByPortIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: makePortStateChangesStreamByPortIdAndAccess
 export const makePortStateChangesStreamByPortIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }

package/src/internal/mutablePropertyTools/doesMutablePortPropertyHaveSpecificValue/doesMutablePortPropertyHaveSpecificValueByPortIdAndAccess.ts

@@ -1,74 +1,74 @@
 // TODO: isInputConnectionClosedByPortIdAndAccess
 export const isInputConnectionClosedByPortIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: isInputConnectionOpenByPortIdAndAccess
 export const isInputConnectionOpenByPortIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: isInputConnectionPendingByPortIdAndAccess
 export const isInputConnectionPendingByPortIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: isInputDeviceConnectedByPortIdAndAccess
 export const isInputDeviceConnectedByPortIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: isInputDeviceDisconnectedByPortIdAndAccess
 export const isInputDeviceDisconnectedByPortIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: isOutputConnectionClosedByPortIdAndAccess
 export const isOutputConnectionClosedByPortIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: isOutputConnectionOpenByPortIdAndAccess
 export const isOutputConnectionOpenByPortIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: isOutputConnectionPendingByPortIdAndAccess
 export const isOutputConnectionPendingByPortIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: isOutputDeviceConnectedByPortIdAndAccess
 export const isOutputDeviceConnectedByPortIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: isOutputDeviceDisconnectedByPortIdAndAccess
 export const isOutputDeviceDisconnectedByPortIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: isPortConnectionClosedByPortIdAndAccess
 export const isPortConnectionClosedByPortIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: isPortConnectionOpenByPortIdAndAccess
 export const isPortConnectionOpenByPortIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: isPortConnectionPendingByPortIdAndAccess
 export const isPortConnectionPendingByPortIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: isPortDeviceConnectedByPortIdAndAccess
 export const isPortDeviceConnectedByPortIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: isPortDeviceDisconnectedByPortIdAndAccess
 export const isPortDeviceDisconnectedByPortIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }

package/src/internal/mutablePropertyTools/doesMutablePortPropertyHaveSpecificValue/doesMutablePortPropertyHaveSpecificValueByPortIdInContext.ts

@@ -1,74 +1,74 @@
 // TODO: isInputConnectionClosedByPortIdInContext
 export const isInputConnectionClosedByPortIdInContext = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: isInputConnectionOpenByPortIdInContext
 export const isInputConnectionOpenByPortIdInContext = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: isInputConnectionPendingByPortIdInContext
 export const isInputConnectionPendingByPortIdInContext = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: isInputDeviceConnectedByPortIdInContext
 export const isInputDeviceConnectedByPortIdInContext = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: isInputDeviceDisconnectedByPortIdInContext
 export const isInputDeviceDisconnectedByPortIdInContext = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: isOutputConnectionClosedByPortIdInContext
 export const isOutputConnectionClosedByPortIdInContext = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: isOutputConnectionOpenByPortIdInContext
 export const isOutputConnectionOpenByPortIdInContext = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: isOutputConnectionPendingByPortIdInContext
 export const isOutputConnectionPendingByPortIdInContext = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: isOutputDeviceConnectedByPortIdInContext
 export const isOutputDeviceConnectedByPortIdInContext = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: isOutputDeviceDisconnectedByPortIdInContext
 export const isOutputDeviceDisconnectedByPortIdInContext = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: isPortConnectionClosedByPortIdInContext
 export const isPortConnectionClosedByPortIdInContext = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: isPortConnectionOpenByPortIdInContext
 export const isPortConnectionOpenByPortIdInContext = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: isPortConnectionPendingByPortIdInContext
 export const isPortConnectionPendingByPortIdInContext = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: isPortDeviceConnectedByPortIdInContext
 export const isPortDeviceConnectedByPortIdInContext = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: isPortDeviceDisconnectedByPortIdInContext
 export const isPortDeviceDisconnectedByPortIdInContext = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }

package/src/internal/mutablePropertyTools/getMutablePortProperty/getMutablePortPropertyByPortIdAndAccess.ts

@@ -91,20 +91,20 @@ export const getPortConnectionStateByPortIdAndAccess = <TE = never, TR = never>(
 
 // TODO: getInputConnectionStateByPortIdAndAccess
 export const getInputConnectionStateByPortIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: getInputDeviceStateByPortIdAndAccess
 export const getInputDeviceStateByPortIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: getOutputConnectionStateByPortIdAndAccess
 export const getOutputConnectionStateByPortIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: getOutputDeviceStateByPortIdAndAccess
 export const getOutputDeviceStateByPortIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }

package/src/internal/mutablePropertyTools/getMutablePortProperty/getMutablePortPropertyByPortIdInContext.ts

@@ -18,20 +18,20 @@ export const getPortConnectionStateByPortId = (id: EMIDIPort.BothId) =>
 
 // TODO: getInputConnectionStateByPortId
 export const getInputConnectionStateByPortId = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: getInputDeviceStateByPortId
 export const getInputDeviceStateByPortId = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: getOutputConnectionStateByPortId
 export const getOutputConnectionStateByPortId = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: getOutputDeviceStateByPortId
 export const getOutputDeviceStateByPortId = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }

package/src/internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPortIdAndAccess.ts

@@ -1,29 +1,29 @@
 // TODO: matchInputConnectionStateByPortIdAndAccess
 export const matchInputConnectionStateByPortIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: matchInputDeviceStateByPortIdAndAccess
 export const matchInputDeviceStateByPortIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: matchOutputConnectionStateByPortIdAndAccess
 export const matchOutputConnectionStateByPortIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: matchOutputDeviceStateByPortIdAndAccess
 export const matchOutputDeviceStateByPortIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: matchPortConnectionStateByPortIdAndAccess
 export const matchPortConnectionStateByPortIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }
 
 // TODO: matchPortDeviceStateByPortIdAndAccess
 export const matchPortDeviceStateByPortIdAndAccess = () => {
-  throw new Error('not implemented')
+  throw new Error('Not implemented 😿  YET!! 🤩')
 }