effect-web-midi 0.2.3

package/src/internal/MIDIErrors.ts

@@ -0,0 +1,260 @@
+import * as Schema from 'effect/Schema'
+import type * as Types from 'effect/Types'
+
+import type * as EMIDIAccess from './EMIDIAccess.ts'
+import * as EMIDIPort from './EMIDIPort.ts'
+
+// NOTE: stacks are properly extracted from error instances into structs, while
+// decoding
+
+const PortId = Schema.fromBrand(EMIDIPort.BothId)(Schema.NonEmptyTrimmedString)
+
+const ErrorSchema = <TSchema extends Schema.Schema.Any | undefined = undefined>(
+  nameSchema?: TSchema,
+) =>
+  Schema.Struct({
+    name: (nameSchema ??
+      Schema.NonEmptyTrimmedString) as TSchema extends undefined
+      ? typeof Schema.NonEmptyTrimmedString
+      : TSchema,
+    message: Schema.NonEmptyTrimmedString,
+    stack: Schema.NonEmptyTrimmedString.pipe(
+      Schema.optionalWith({ exact: true }),
+    ),
+    cause: Schema.Unknown.pipe(Schema.optionalWith({ exact: true })),
+  })
+
+const midiAccessFailureFields = {
+  whileAskingForPermissions: Schema.Struct({
+    sysex: Schema.optional(Schema.Boolean),
+    software: Schema.optional(Schema.Boolean),
+  }),
+}
+
+/**
+ * Thrown if the document or page is going to be closed due to user navigation.
+ *
+ * Wraps `DOMException { name: 'AbortError' }`
+ *
+ * @see {@link https://webidl.spec.whatwg.org/#aborterror|Web IDL spec}
+ */
+export class AbortError extends Schema.TaggedError<AbortError>()('AbortError', {
+  cause: ErrorSchema(Schema.Literal('AbortError')),
+}) {
+  override get message() {
+    return `MIDI access request was interrupted by user navigation, likely because the page was closed`
+  }
+}
+
+/**
+ * Thrown if the underlying system raises any errors when trying to open the
+ * port.
+ *
+ * Wraps `DOMException { name: 'InvalidStateError' }`
+ *
+ * @see {@link https://webidl.spec.whatwg.org/#invalidstateerror|Web IDL spec}
+ */
+export class UnderlyingSystemError extends Schema.TaggedError<UnderlyingSystemError>()(
+  'UnderlyingSystemError',
+  {
+    cause: ErrorSchema(Schema.Literal('InvalidStateError')),
+    ...midiAccessFailureFields,
+  },
+) {
+  override get message() {
+    return `Underlying system (OS/browser) raised an error when attempting to open the port`
+  }
+}
+
+/**
+ * Thrown if the MIDI API, or a certain configuration of it is not supported by
+ * the system.
+ *
+ * Wraps `ReferenceError | TypeError | DOMException { name: 'NotSupportedError' }`
+ *
+ * @see {@link https://webidl.spec.whatwg.org/#notsupportederror|Web IDL spec}
+ */
+export class MIDIAccessNotSupportedError extends Schema.TaggedError<MIDIAccessNotSupportedError>()(
+  'MIDIAccessNotSupportedError',
+  {
+    cause: ErrorSchema(
+      Schema.Literal('ReferenceError', 'TypeError', 'NotSupportedError'),
+    ),
+    ...midiAccessFailureFields,
+  },
+) {
+  override get message() {
+    return `This platform doesn't support Web MIDI API`
+  }
+}
+
+/**
+ * Thrown on platforms where `.clear()` method of output ports is not supported
+ * (currently supported only in Firefox)
+ *
+ * Wraps `TypeError | DOMException { name: 'NotSupportedError' }`
+ *
+ * @see {@link https://webidl.spec.whatwg.org/#notsupportederror|Web IDL spec}
+ */
+export class ClearingSendingQueueIsNotSupportedError extends Schema.TaggedError<ClearingSendingQueueIsNotSupportedError>()(
+  'ClearingSendingQueueIsNotSupportedError',
+  {
+    cause: ErrorSchema(Schema.Literal('TypeError', 'NotSupportedError')),
+    portId: PortId,
+  },
+) {
+  override get message() {
+    return `This platform doesn't support "MIDIOutput.prototype.clear()" method`
+  }
+}
+
+/**
+ * Thrown when attempt to open the port failed because it is unavailable (e.g.
+ * is already in use by another process and cannot be opened, or is
+ * disconnected).
+ *
+ * Wraps `DOMException { name: 'InvalidAccessError' | 'NotAllowedError' | 'InvalidStateError' }`
+ *
+ * @see Web IDL specs: {@link https://webidl.spec.whatwg.org/#invalidaccesserror|InvalidAccessError}, {@link https://webidl.spec.whatwg.org/#notallowederror|NotAllowedError}, {@link https://webidl.spec.whatwg.org/#invalidstateerror|InvalidStateError}
+ */
+export class CannotOpenUnavailablePortError extends Schema.TaggedError<CannotOpenUnavailablePortError>()(
+  'CannotOpenUnavailablePortError',
+  {
+    cause: ErrorSchema(
+      Schema.Literal(
+        'InvalidAccessError',
+        'NotAllowedError',
+        'InvalidStateError',
+      ),
+    ),
+    portId: PortId,
+  },
+) {
+  override get message() {
+    return `Cannot open an unavailable port. This might happen when it's already in use by another process or is disconnected`
+  }
+}
+
+/**
+ * Thrown when `.send` operation was called on a disconnected port.
+ *
+ * Wraps `DOMException { name: 'InvalidStateError' }`
+ *
+ * @see {@link https://webidl.spec.whatwg.org/#invalidaccesserror|Web IDL spec}
+ */
+export class CannotSendToDisconnectedPortError extends Schema.TaggedError<CannotSendToDisconnectedPortError>()(
+  'CannotSendToDisconnectedPortError',
+  {
+    cause: ErrorSchema(Schema.Literal('InvalidStateError')),
+    portId: PortId,
+  },
+) {
+  override get message() {
+    return `Cannot send a MIDI message to a disconnected port`
+  }
+}
+
+/**
+ * Thrown when trying to send system exclusive message from the access handle,
+ * that doesn't have this permission
+ *
+ * Wraps `DOMException { name: 'InvalidAccessError' | 'NotAllowedError' }`
+ *
+ * @see Web IDL specs: {@link https://webidl.spec.whatwg.org/#invalidaccesserror|InvalidAccessError}, {@link https://webidl.spec.whatwg.org/#notallowederror|NotAllowedError}
+ */
+export class CannotSendSysexMessageError extends Schema.TaggedError<CannotSendSysexMessageError>()(
+  'CannotSendSysexMessageError',
+  {
+    cause: ErrorSchema(Schema.Literal('InvalidAccessError', 'NotAllowedError')),
+    portId: PortId,
+  },
+) {
+  override get message() {
+    return `Cannot send a system exclusive MIDI message from a MIDI access handle that wasn't permitted to send such messages`
+  }
+}
+
+/**
+ * Thrown if the user, the system or their security settings denied the
+ * application from creating an {@linkcode EMIDIAccess.EMIDIAccessInstance} object
+ * with the requested {@linkcode EMIDIAccess.RequestMIDIAccessOptions|options}, or if the
+ * document is not allowed to use the feature (for example, because of a
+ * Permission Policy, or because the user previously denied a permission
+ * request).
+ *
+ * Wraps `DOMException { name: 'NotAllowedError' | 'SecurityError' }`
+ *
+ * @see Web IDL specs: {@link https://webidl.spec.whatwg.org/#notallowederror|NotAllowedError}, {@link https://webidl.spec.whatwg.org/#securityerror|SecurityError}
+ */
+export class MIDIAccessNotAllowedError extends Schema.TaggedError<MIDIAccessNotAllowedError>()(
+  'MIDIAccessNotAllowedError',
+  {
+    cause: ErrorSchema(Schema.Literal('NotAllowedError', 'SecurityError')),
+    ...midiAccessFailureFields,
+  },
+) {
+  override get message() {
+    return `Request to use Web MIDI API with specific options was rejected by the user or their security settings`
+  }
+}
+
+/**
+ * Thrown when data to be sent is not a valid sequence or does not contain a
+ * valid MIDI message
+ *
+ * Wraps `TypeError`
+ */
+export class MalformedMIDIMessageError extends Schema.TaggedError<MalformedMIDIMessageError>()(
+  'MalformedMIDIMessageError',
+  {
+    cause: ErrorSchema(Schema.Literal('TypeError')),
+    portId: PortId,
+    midiMessage: Schema.Array(Schema.Int),
+  },
+) {
+  override get message() {
+    return `Attempted to send invalid MIDI message (${this.midiMessage.length} bytes)`
+  }
+}
+
+/**
+ * Keep in mind that if port isn't found, it might not mean it's disconnected.
+ * For example, virtual ports created by software won't show up in the list of
+ * available inputs/outputs of MIDI Access handle with disabled
+ * {@linkcode EMIDIAccess.RequestMIDIAccessOptions.software} flag.
+ */
+export class PortNotFoundError extends Schema.TaggedError<PortNotFoundError>()(
+  'PortNotFound',
+  { portId: PortId },
+) {
+  override get message() {
+    return `Port with specific ID wasn't found`
+  }
+}
+
+// TODO: Make so that the function also ensures that cause.name is properly matches the map arg field it's assigned from, so that consistency goes both ways
+/**
+ *
+ * @internal
+ */
+export const remapErrorByName =
+  <TErrorClassUnion extends new (arg: any) => Error>(
+    map: { [name: string]: TErrorClassUnion },
+    absurdMessage: string,
+    rest: Omit<
+      Types.UnionToIntersection<
+        TErrorClassUnion extends new (arg: infer P) => any ? P : never
+      >,
+      'cause'
+    >,
+  ) =>
+  (cause: unknown) => {
+    if (!(cause instanceof Error && cause.name in map))
+      throw new Error(absurdMessage)
+    // biome-ignore lint/style/noNonNullAssertion: Because we checked it above with `cause.name in map`
+    const Class = map[cause.name]!
+    return new Class({
+      cause,
+      ...rest,
+    }) as InstanceType<TErrorClassUnion>
+  }

package/src/internal/MIDIEventStreams.ts

@@ -0,0 +1,255 @@
+import * as EFunction from 'effect/Function'
+import * as Stream from 'effect/Stream'
+
+import * as EMIDIAccess from './EMIDIAccess.ts'
+import * as EMIDIInput from './EMIDIInput.ts'
+import { getInputByPortIdAndAccess } from './getPortByPortId/getPortByPortIdAndAccess.ts'
+import type * as MIDIErrors from './MIDIErrors.ts'
+import * as Parsing from './Parsing.ts'
+import type * as StreamMaker from './StreamMaker.ts'
+import * as Util from './Util.ts'
+
+const buildSpecificEventStreamByInputIdAndAccessMaker = <
+  Payload extends Parsing.TaggedObject,
+>(
+  predicate: Parsing.MessagePredicate<Payload>,
+): DualMakeSpecificMessageStreamFromAccess<Payload> => {
+  const makeSpecificMessageStreamByInput =
+    buildSpecificMessageStreamByInputMaker(predicate)
+
+  return EFunction.dual(
+    Util.polymorphicCheckInDual(EMIDIAccess.is),
+    (polymorphicAccess, id, options) =>
+      makeSpecificMessageStreamByInput(
+        getInputByPortIdAndAccess(polymorphicAccess, id),
+        options,
+      ),
+  )
+}
+
+const buildSpecificMessagesStreamByInputIdInContextMaker = <
+  Payload extends Parsing.TaggedObject,
+>(
+  predicate: Parsing.MessagePredicate<Payload>,
+) => {
+  const makeSpecificMessageStreamByAccess =
+    buildSpecificEventStreamByInputIdAndAccessMaker(predicate)
+
+  return <const TForbidNullsStrategy extends ForbidNullsStrategy = undefined>(
+    id: EMIDIInput.Id,
+    options?: StreamMaker.StreamMakerOptions<TForbidNullsStrategy>,
+  ) => makeSpecificMessageStreamByAccess(EMIDIAccess.EMIDIAccess, id, options)
+}
+
+const buildSpecificMessageStreamByInputMaker = <
+  Payload extends Parsing.TaggedObject,
+>(
+  predicate: Parsing.MessagePredicate<Payload>,
+): DualMakeSpecificMessageStreamFromInput<Payload> =>
+  EFunction.dual(
+    Util.polymorphicCheckInDual(EMIDIInput.is),
+    EFunction.flow(
+      EMIDIInput.makeMessagesStreamByPort as any,
+      Parsing.withParsedDataField,
+      Stream.filter(predicate),
+    ),
+  )
+
+export type ForbidNullsStrategy = Exclude<
+  StreamMaker.OnNullStrategy,
+  'passthrough'
+>
+
+export interface DualMakeSpecificMessageStreamFromInput<
+  Payload extends Parsing.TaggedObject,
+> extends MakeSpecificMessageStreamInputLast<Payload>,
+    MakeSpecificMessageStreamInputFirst<Payload> {}
+
+export interface MakeSpecificMessageStreamInputFirst<
+  Payload extends Parsing.TaggedObject,
+> {
+  /**
+   *
+   */
+  <
+    E = never,
+    R = never,
+    const TForbidNullsStrategy extends ForbidNullsStrategy = undefined,
+  >(
+    polymorphicInput: EMIDIInput.PolymorphicInput<E, R>,
+    options?: StreamMaker.StreamMakerOptions<TForbidNullsStrategy>,
+  ): MakeSpecificMessageStreamResult<Payload, TForbidNullsStrategy, E, R>
+}
+
+export interface MakeSpecificMessageStreamInputLast<
+  Payload extends Parsing.TaggedObject,
+> {
+  /**
+   *
+   */
+  <const TForbidNullsStrategy extends ForbidNullsStrategy = undefined>(
+    options?: StreamMaker.StreamMakerOptions<TForbidNullsStrategy>,
+  ): MakeSpecificMessageStreamInputLastSecondPart<Payload, TForbidNullsStrategy>
+}
+
+export interface MakeSpecificMessageStreamInputLastSecondPart<
+  Payload extends Parsing.TaggedObject,
+  TForbidNullsStrategy extends ForbidNullsStrategy,
+> {
+  /**
+   *
+   */
+  <E = never, R = never>(
+    polymorphicInput: EMIDIInput.PolymorphicInput<E, R>,
+  ): MakeSpecificMessageStreamResult<Payload, TForbidNullsStrategy, E, R>
+}
+
+////////////////////////////////////////////////////
+////////////////////////////////////////////////////
+////////////////////////////////////////////////////
+
+export interface DualMakeSpecificMessageStreamFromAccess<
+  Payload extends Parsing.TaggedObject,
+> extends MakeSpecificMessageStreamAccessLast<Payload>,
+    MakeSpecificMessageStreamAccessFirst<Payload> {}
+
+export interface MakeSpecificMessageStreamAccessFirst<
+  Payload extends Parsing.TaggedObject,
+> {
+  /**
+   *
+   */
+  <
+    E = never,
+    R = never,
+    const TForbidNullsStrategy extends ForbidNullsStrategy = undefined,
+  >(
+    polymorphicAccess: EMIDIAccess.PolymorphicAccessInstance<E, R>,
+    id: EMIDIInput.Id,
+    options?: StreamMaker.StreamMakerOptions<TForbidNullsStrategy>,
+  ): MakeSpecificMessageStreamResult<
+    Payload,
+    TForbidNullsStrategy,
+    E | MIDIErrors.PortNotFoundError,
+    R
+  >
+}
+
+export interface MakeSpecificMessageStreamAccessLast<
+  Payload extends Parsing.TaggedObject,
+> {
+  /**
+   *
+   */
+  <const TForbidNullsStrategy extends ForbidNullsStrategy = undefined>(
+    id: EMIDIInput.Id,
+    options?: StreamMaker.StreamMakerOptions<TForbidNullsStrategy>,
+  ): MakeSpecificMessageStreamAccessLastSecondPart<
+    Payload,
+    TForbidNullsStrategy
+  >
+}
+
+export interface MakeSpecificMessageStreamAccessLastSecondPart<
+  Payload extends Parsing.TaggedObject,
+  TForbidNullsStrategy extends ForbidNullsStrategy,
+> {
+  /**
+   *
+   */
+  <E = never, R = never>(
+    polymorphicAccess: EMIDIAccess.PolymorphicAccessInstance<E, R>,
+  ): MakeSpecificMessageStreamResult<
+    Payload,
+    TForbidNullsStrategy,
+    E | MIDIErrors.PortNotFoundError,
+    R
+  >
+}
+
+export interface MakeSpecificMessageStreamResult<
+  Payload extends Parsing.TaggedObject,
+  TForbidNullsStrategy extends ForbidNullsStrategy,
+  E,
+  R,
+> extends Stream.Stream<
+    Parsing.ParsedMIDIMessage<Payload>,
+    StreamMaker.StreamError<TForbidNullsStrategy, E>,
+    R
+  > {}
+
+export const makeNoteReleaseStreamByInput =
+  buildSpecificMessageStreamByInputMaker(Parsing.isNoteRelease)
+
+export const makeNoteReleaseStreamByInputIdAndAccess =
+  buildSpecificEventStreamByInputIdAndAccessMaker(Parsing.isNoteRelease)
+
+export const makeNoteReleaseStreamByInputIdInContext =
+  buildSpecificMessagesStreamByInputIdInContextMaker(Parsing.isNoteRelease)
+
+export const makeNotePressStreamByInput =
+  buildSpecificMessageStreamByInputMaker(Parsing.isNotePress)
+
+export const makeNotePressStreamByInputIdAndAccess =
+  buildSpecificEventStreamByInputIdAndAccessMaker(Parsing.isNotePress)
+
+export const makeNotePressStreamByInputIdInContext =
+  buildSpecificMessagesStreamByInputIdInContextMaker(Parsing.isNotePress)
+
+export const makeUnknownReplyStreamByInput =
+  buildSpecificMessageStreamByInputMaker(Parsing.isUnknownReply)
+
+export const makeUnknownReplyStreamByInputIdAndAccess =
+  buildSpecificEventStreamByInputIdAndAccessMaker(Parsing.isUnknownReply)
+
+export const makeUnknownReplyStreamByInputIdInContext =
+  buildSpecificMessagesStreamByInputIdInContextMaker(Parsing.isUnknownReply)
+
+export const makeControlChangeStreamByInput =
+  buildSpecificMessageStreamByInputMaker(Parsing.isControlChange)
+
+export const makeControlChangeStreamByInputIdAndAccess =
+  buildSpecificEventStreamByInputIdAndAccessMaker(Parsing.isControlChange)
+
+export const makeControlChangeStreamByInputIdInContext =
+  buildSpecificMessagesStreamByInputIdInContextMaker(Parsing.isControlChange)
+
+export const makeChannelPressureStreamByInput =
+  buildSpecificMessageStreamByInputMaker(Parsing.isChannelPressure)
+
+export const makeChannelPressureStreamByInputIdAndAccess =
+  buildSpecificEventStreamByInputIdAndAccessMaker(Parsing.isChannelPressure)
+
+export const makeChannelPressureStreamByInputIdInContext =
+  buildSpecificMessagesStreamByInputIdInContextMaker(Parsing.isChannelPressure)
+
+export const makeTouchpadReleaseStreamByInput =
+  buildSpecificMessageStreamByInputMaker(Parsing.isTouchpadRelease)
+
+export const makeTouchpadReleaseStreamByInputIdAndAccess =
+  buildSpecificEventStreamByInputIdAndAccessMaker(Parsing.isTouchpadRelease)
+
+export const makeTouchpadReleaseStreamByInputIdInContext =
+  buildSpecificMessagesStreamByInputIdInContextMaker(Parsing.isTouchpadRelease)
+
+export const makePitchBendChangeStreamByInput =
+  buildSpecificMessageStreamByInputMaker(Parsing.isPitchBendChange)
+
+export const makePitchBendChangeStreamByInputIdAndAccess =
+  buildSpecificEventStreamByInputIdAndAccessMaker(Parsing.isPitchBendChange)
+
+export const makePitchBendChangeStreamByInputIdInContext =
+  buildSpecificMessagesStreamByInputIdInContextMaker(Parsing.isPitchBendChange)
+
+export const makeTouchpadPositionUpdateStreamByInput =
+  buildSpecificMessageStreamByInputMaker(Parsing.isTouchpadPositionUpdate)
+
+export const makeTouchpadPositionUpdateStreamByInputIdAndAccess =
+  buildSpecificEventStreamByInputIdAndAccessMaker(
+    Parsing.isTouchpadPositionUpdate,
+  )
+
+export const makeTouchpadPositionUpdateStreamByInputIdInContext =
+  buildSpecificMessagesStreamByInputIdInContextMaker(
+    Parsing.isTouchpadPositionUpdate,
+  )

package/src/internal/MIDIPortMethodCalls/acquireReleasePortConnection/acquireReleasePortConnectionByPort.ts

@@ -0,0 +1,48 @@
+import * as Effect from 'effect/Effect'
+import type * as Scope from 'effect/Scope'
+
+import * as EMIDIInput from '../../EMIDIInput.ts'
+import * as EMIDIOutput from '../../EMIDIOutput.ts'
+import * as EMIDIPort from '../../EMIDIPort.ts'
+import type * as MIDIErrors from '../../MIDIErrors.ts'
+import * as Close from '../closePortConnection/closePortConnectionByPort.ts'
+import type { TouchPort } from '../makeMIDIPortMethodCallerFactory.ts'
+import * as Open from '../openPortConnection/openPortConnectionByPort.ts'
+
+/**
+ * @internal
+ */
+const makeConnectionAcquirerReleaser =
+  <THighLevelPortType extends MIDIPortType>(
+    is: (port: unknown) => port is EMIDIPort.EMIDIPort<THighLevelPortType>,
+  ): TouchPort<
+    MIDIErrors.CannotOpenUnavailablePortError,
+    Scope.Scope,
+    THighLevelPortType
+  > =>
+  /**
+   * @returns An effect with the same port for easier chaining of operations
+   */
+  port =>
+    Effect.acquireRelease(
+      Open.makePortConnectionOpener(is)(port),
+      Close.makePortConnectionCloser(is),
+    )
+
+/**
+ *
+ */
+export const acquireReleasePortConnectionByPort =
+  makeConnectionAcquirerReleaser(EMIDIPort.is)
+
+/**
+ *
+ */
+export const acquireReleaseInputConnectionByPort =
+  makeConnectionAcquirerReleaser(EMIDIInput.is)
+
+/**
+ *
+ */
+export const acquireReleaseOutputConnectionByPort =
+  makeConnectionAcquirerReleaser(EMIDIOutput.is)

package/src/internal/MIDIPortMethodCalls/acquireReleasePortConnection/acquireReleasePortConnectionByPortIdAndAccess.ts

@@ -0,0 +1,31 @@
+// TODO: acquireReleasePortConnectionByPortIdAndAccess.ts
+/** biome-ignore-all lint/style/useShorthandFunctionType: It's a nice way to
+ * preserve JSDoc comments attached to the function signature */
+
+import * as Get from '../../getPortByPortId/getPortByPortIdAndAccess.ts'
+import { actOnPort } from '../actOnPort.ts'
+import * as AR from './acquireReleasePortConnectionByPort.ts'
+
+/**
+ *
+ */
+export const acquireReleasePortConnectionByPortIdAndAccess = actOnPort(
+  Get.getPortByPortIdAndAccess,
+  AR.acquireReleasePortConnectionByPort,
+)
+
+/**
+ *
+ */
+export const acquireReleaseInputConnectionByPortIdAndAccess = actOnPort(
+  Get.getInputByPortIdAndAccess,
+  AR.acquireReleaseInputConnectionByPort,
+)
+
+/**
+ *
+ */
+export const acquireReleaseOutputConnectionByPortIdAndAccess = actOnPort(
+  Get.getOutputByPortIdAndAccess,
+  AR.acquireReleaseOutputConnectionByPort,
+)

package/src/internal/MIDIPortMethodCalls/acquireReleasePortConnection/acquireReleasePortConnectionByPortIdInContext.ts

@@ -0,0 +1,28 @@
+import { flow } from 'effect/Function'
+
+import * as Get from '../../getPortByPortId/getPortByPortIdInContext.ts'
+import * as Acquire from './acquireReleasePortConnectionByPort.ts'
+
+/**
+ *
+ */
+export const acquireReleasePortConnectionByPortIdInContext = flow(
+  Get.getPortByPortIdInContext,
+  Acquire.acquireReleasePortConnectionByPort,
+)
+
+/**
+ *
+ */
+export const acquireReleaseInputConnectionByPortIdInContext = flow(
+  Get.getInputByPortIdInContext,
+  Acquire.acquireReleaseInputConnectionByPort,
+)
+
+/**
+ *
+ */
+export const acquireReleaseOutputConnectionByPortIdInContext = flow(
+  Get.getOutputByPortIdInContext,
+  Acquire.acquireReleaseOutputConnectionByPort,
+)

package/src/internal/MIDIPortMethodCalls/actOnPort.ts

@@ -0,0 +1,66 @@
+/** biome-ignore-all lint/style/useShorthandFunctionType: It's a nice way to
+ * preserve JSDoc comments attached to the function signature */
+
+import * as Effect from 'effect/Effect'
+import * as EFunction from 'effect/Function'
+
+import * as EMIDIAccess from '../EMIDIAccess.ts'
+import type * as EMIDIPort from '../EMIDIPort.ts'
+import type * as Get from '../getPortByPortId/getPortByPortIdAndAccess.ts'
+import type * as Make from './makeMIDIPortMethodCallerFactory.ts'
+
+/**
+ *
+ * @internal
+ */
+export const actOnPort = <
+  TTypeOfPortId extends MIDIPortType,
+  TPortTypeReturnedFromAccess extends TPortTypeSupportedInActing &
+    TTypeOfPortId,
+  TPortTypeSupportedInActing extends MIDIPortType,
+  TPortGettingError = never,
+  TPortGettingRequirement = never,
+  TPortActingError = never,
+  TPortActingRequirement = never,
+>(
+  getPortFromAccessAndPortId: Get.GetPortById<
+    TPortTypeReturnedFromAccess,
+    TTypeOfPortId,
+    never,
+    never,
+    TPortGettingError,
+    TPortGettingRequirement
+  >,
+  act: Make.TouchPort<
+    TPortActingError,
+    TPortActingRequirement,
+    TPortTypeSupportedInActing
+  >,
+): EMIDIAccess.GetThingByPortId<
+  EMIDIAccess.EMIDIAccessInstance,
+  TPortTypeReturnedFromAccess,
+  never,
+  never,
+  TPortGettingError | TPortActingError,
+  TPortGettingRequirement | TPortActingRequirement
+> =>
+  EFunction.dual(
+    2,
+    (polymorphicAccess, portId) =>
+      Effect.gen(function* () {
+        const access = yield* EMIDIAccess.simplify(polymorphicAccess)
+
+        const port = yield* getPortFromAccessAndPortId(
+          access,
+          portId as unknown as EMIDIPort.Id<TTypeOfPortId>,
+        )
+
+        const actEffect = act(
+          port as unknown as EMIDIPort.EMIDIPort<TPortTypeSupportedInActing>,
+        )
+
+        yield* actEffect
+
+        return access
+      }) as any,
+  )