effect-web-midi 0.2.3

package/README.md

@@ -0,0 +1,276 @@
+# Effect Web MIDI API wrapper
+
+Huge thanks to [Web MIDI spec](https://www.w3.org/TR/webmidi/)!
+
+## Early Adopters
+
+1. Etude ([GitHub](https://github.com/MichaelVessia/etude), [Web
+   site](https://etude.vessia.net/)) -- A self-hosted piano practice tool built
+   by Michael Vessia ([GitHub @michaelvessia](https://github.com/michaelvessia),
+   [Web Site](https://vessia.net/)) that scores your performance against sheet
+   music. Connect a MIDI keyboard, load a piece, play through it, and get
+   real-time feedback on accuracy.
+2. And, hopefully, You 😉 🫶 Please 🙏
+
+## Potential Adopters
+
+1. [chris-albert/midi-structor](https://github.com/chris-albert/midi-structor)
+2. [Search on GitHub for `effect` and `requestMIDIAccess`...](https://github.com/search?q=%2F%28from+%7Crequire%5C%28%29%5B%27%22%5D%40%3Feffect%5B%27%22%5C%2F%5D%2F+language%3Atypescript+NOT+is%3Afork+requestMIDIAccess+NOT+owner%3Anikelborm&type=code)
+
+## Devices the lib was manually tested on
+
+1. [Novation Launchpad X](https://novationmusic.com/products/launchpad-x)
+2. KORG NanoPad v1
+3. If you tested it on some devices not listed here, feel free to report your results through [GitHub issues](https://github.com/nikelborm/effect-garden/issues)
+
+## Demo
+
+```ts
+'use client';
+import { Atom, Result, useAtom, useAtomValue } from '@effect-atom/atom-react';
+import { styled } from '@linaria/react';
+import * as Cause from 'effect/Cause';
+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 * 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 nanoPadOutputId = EMIDIOutput.Id(
+  '045297AACE044DA224B59E92DBC0E874160B85D0D43BE505CBB053747F4AA90A'
+);
+
+const globalDataDumpRequest = new Uint8Array([
+  0xf0, 0x42, 0x40 /* 4g */,
+  //
+  0x00, 0x01, 0x03, 0x00,
+  //
+  0x1f, 0x0e, 0x00, 0xf7,
+]);
+
+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) =>
+      a.midiMessage._tag === 'Touchpad Position Update' ||
+      a.midiMessage._tag === 'Touchpad Release' ||
+      a.midiMessage._tag === 'Note Press' ||
+      a.midiMessage._tag === 'Note Release'
+  ),
+  // Just for the demo, show only select list of events
+  Util.mapToGlidingStringLogOfLimitedEntriesCount(
+    50,
+    'latestFirst',
+    (current) => ({
+      time: current.capturedAt.toISOString(),
+      id: current.cameFrom.id.slice(-10),
+      ...current.midiMessage,
+    })
+  ),
+  // ⬆️ 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
+    //             >
+    nanoPadOutputId,
+    // ⬆️ string & Brand<"MIDIPortId"> & Brand<"output">
+    globalDataDumpRequest
+    // ⬆️ Uint8Array<ArrayBuffer>
+  )
+);
+
+const textAtom = Atom.make(
+  // MIDIDeviceConnectionEventsStringLog,
+  MIDIMessageEventsStringLog
+).pipe(Atom.keepAlive);
+
+export default function Home() {
+  const text = useAtomValue(textAtom);
+  console.log(text);
+  const [, mutate] = useAtom(dumpRequester);
+
+  return (
+    <Wrapper>
+      <form
+        onSubmit={(event) => {
+          event.preventDefault();
+          mutate();
+        }}
+      >
+        <input type='submit' value='dump' />
+      </form>
+
+      {Result.match(text, {
+        onFailure: (_) => (
+          <>
+            failure:
+            <br />
+            {Cause.pretty(_.cause)}
+          </>
+        ),
+        onInitial: (e) => <>initial waiting: {e.waiting.toString()}</>,
+        onSuccess: (s) => <pre>{s.value}</pre>,
+      })}
+    </Wrapper>
+  );
+}
+
+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)
+
+## TODO
+
+1. tests ([useful example](https://chromium-review.googlesource.com/c/chromium/src/+/7242095/1/third_party/blink/web_tests/wpt_internal/webmidi/requestmidiaccess.https.html))

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './src/index.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAA"}

package/dist/src/EMIDIAccess.js

@@ -0,0 +1,129 @@
+export { AllPortsArray, AllPortsRecord, assert, clearPortById, EMIDIAccess, getAllPortsArray, getAllPortsRecord, getInputsArray, getInputsRecord, getOutputsArray, getOutputsRecord, InputsArray, InputsRecord, is, layer, layerMostRestricted, layerSoftwareSynthSupported, layerSystemExclusiveAndSoftwareSynthSupported, layerSystemExclusiveSupported, makeAllPortsStateChangesStream, makeAllPortsStateChangesStreamInContext, makeMessagesStreamByInputId, makeMessagesStreamByInputIdAndAccess, OutputsArray, OutputsRecord, request, send, sendInContext, sendToPortById, } from './internal/EMIDIAccess.js';
+// export {
+//   assert,
+//   type EMIDIInput,
+//   is,
+//   make,
+//   makeMessagesStreamByPort,
+//   type PolymorphicInput,
+//   type PolymorphicInputClean,
+// } from './internal/EMIDIInput.ts'
+// export {
+//   assert,
+//   clear,
+//   type DualSendMIDIMessageFromPort,
+//   type EMIDIOutput,
+//   is,
+//   make,
+//   type PolymorphicOutput,
+//   type PolymorphicOutputClean,
+//   type SendFromPortArgs,
+//   type SendMIDIMessagePortFirst,
+//   type SendMIDIMessagePortLast,
+//   type SentMessageEffectFromPort,
+//   send,
+// } from './internal/EMIDIOutput.ts'
+// export {
+//   assert,
+//   assumeImpl,
+//   type EMIDIPort,
+//   BothId,
+//   type Id,
+//   type EMIDIPortImpl,
+//   type ExtractTypeFromPort,
+//   is,
+//   isImplOfSpecificType,
+//   makeImpl,
+//   type PolymorphicPort,
+//   type PolymorphicPortClean,
+//   type TypeId,
+// } from './internal/EMIDIPort.ts'
+export { getInputByPortIdAndAccess as getInputByIdInPipe, getOutputByPortIdAndAccess as getOutputByIdInPipe, getPortByPortIdAndAccess as getPortByIdInPipe, } from './internal/getPortByPortId/getPortByPortIdAndAccess.js';
+export { getInputByPortIdInContext as getInputById, getOutputByPortIdInContext as getOutputById, getPortByPortIdInContext as getPortById, } from './internal/getPortByPortId/getPortByPortIdInContext.js';
+// export {
+//   acquireReleaseInputConnectionByPort,
+//   acquireReleaseOutputConnectionByPort,
+//   acquireReleasePortConnectionByPort,
+// } from './internal/MIDIPortMethodCalls/acquireReleasePortConnection/acquireReleasePortConnectionByPort.ts'
+export { acquireReleaseInputConnectionByPortIdAndAccess as acquireReleaseInputConnectionByIdInPipe, acquireReleaseOutputConnectionByPortIdAndAccess as acquireReleaseOutputConnectionByIdInPipe, acquireReleasePortConnectionByPortIdAndAccess as acquireReleasePortConnectionByIdInPipe, } from './internal/MIDIPortMethodCalls/acquireReleasePortConnection/acquireReleasePortConnectionByPortIdAndAccess.js';
+export { acquireReleaseInputConnectionByPortIdInContext as acquireReleaseInputConnectionById, acquireReleaseOutputConnectionByPortIdInContext as acquireReleaseOutputConnectionById, acquireReleasePortConnectionByPortIdInContext as acquireReleasePortConnectionById, } from './internal/MIDIPortMethodCalls/acquireReleasePortConnection/acquireReleasePortConnectionByPortIdInContext.js';
+// export { actOnPort } from './internal/MIDIPortMethodCalls/actOnPort.ts'
+// export {
+//   closeInputConnectionByPort,
+//   closeOutputConnectionByPort,
+//   closePortConnectionByPort,
+//   makePortConnectionCloser,
+// } from './internal/MIDIPortMethodCalls/closePortConnection/closePortConnectionByPort.ts'
+export { closeInputConnectionByPortIdAndAccess as closeInputConnectionByIdInPipe, closeOutputConnectionByPortIdAndAccess as closeOutputConnectionByIdInPipe, closePortConnectionByPortIdAndAccess as closePortConnectionByIdInPipe, } from './internal/MIDIPortMethodCalls/closePortConnection/closePortConnectionByPortIdAndAccess.js';
+export { closeInputConnectionByPortIdInContext as closeInputConnectionById, closeOutputConnectionByPortIdInContext as closeOutputConnectionById, closePortConnectionByPortIdInContext as closePortConnectionById, } from './internal/MIDIPortMethodCalls/closePortConnection/closePortConnectionByPortIdInContext.js';
+// export {
+//   makeMIDIPortMethodCallerFactory,
+//   type TouchPort,
+// } from './internal/MIDIPortMethodCalls/makeMIDIPortMethodCallerFactory.ts'
+// export {
+//   makePortConnectionOpener,
+//   openInputConnectionByPort,
+//   openOutputConnectionByPort,
+//   openPortConnectionByPort,
+// } from './internal/MIDIPortMethodCalls/openPortConnection/openPortConnectionByPort.ts'
+export { openInputConnectionByPortIdAndAccess as openInputConnectionByIdInPipe, openOutputConnectionByPortIdAndAccess as openOutputConnectionByIdInPipe, openPortConnectionByPortIdAndAccess as openPortConnectionByIdInPipe, } from './internal/MIDIPortMethodCalls/openPortConnection/openPortConnectionByPortIdAndAccess.js';
+export { openInputConnectionByPortIdInContext as openInputConnectionById, openOutputConnectionByPortIdInContext as openOutputConnectionById, openPortConnectionByPortIdInContext as openPortConnectionById, } from './internal/MIDIPortMethodCalls/openPortConnection/openPortConnectionByPortIdInContext.js';
+// export {
+//   type DualMakeStateChangesStream,
+//   type MakeStateChangesStreamPortFirst,
+//   type MakeStateChangesStreamPortLast,
+//   makeInputStateChangesStreamByPort,
+//   makeOutputStateChangesStreamByPort,
+//   makePortStateChangesStreamByPort,
+//   type StateChangesStream,
+// } from './internal/makePortStateChangesStream/makePortStateChangesStreamByPort.ts'
+export { makeInputStateChangesStreamByPortIdAndAccess as makeInputStateChangesStreamByIdInPipe, makeOutputStateChangesStreamByPortIdAndAccess as makeOutputStateChangesStreamByIdInPipe, makePortStateChangesStreamByPortIdAndAccess as makePortStateChangesStreamByIdInPipe, } from './internal/makePortStateChangesStream/makePortStateChangesStreamByPortIdAndAccess.js';
+export { makeInputStateChangesStreamByPortIdInContext as makeInputStateChangesStreamById, makeOutputStateChangesStreamByPortIdInContext as makeOutputStateChangesStreamById, makePortStateChangesStreamByPortIdInContext as makePortStateChangesStreamById, } from './internal/makePortStateChangesStream/makePortStateChangesStreamByPortIdInContext.js';
+// export {
+//   isInputConnectionClosedByPort,
+//   isInputConnectionOpenByPort,
+//   isInputConnectionPendingByPort,
+//   isInputDeviceConnectedByPort,
+//   isInputDeviceDisconnectedByPort,
+//   isOutputConnectionClosedByPort,
+//   isOutputConnectionOpenByPort,
+//   isOutputConnectionPendingByPort,
+//   isOutputDeviceConnectedByPort,
+//   isOutputDeviceDisconnectedByPort,
+//   isPortConnectionClosedByPort,
+//   isPortConnectionOpenByPort,
+//   isPortConnectionPendingByPort,
+//   isPortDeviceConnectedByPort,
+//   isPortDeviceDisconnectedByPort,
+// } from './internal/mutablePropertyTools/doesMutablePortPropertyHaveSpecificValue/doesMutablePortPropertyHaveSpecificValueByPort.ts'
+export { isInputConnectionClosedByPortIdAndAccess as isInputConnectionClosedByIdInPipe, isInputConnectionOpenByPortIdAndAccess as isInputConnectionOpenByIdInPipe, isInputConnectionPendingByPortIdAndAccess as isInputConnectionPendingByIdInPipe, isInputDeviceConnectedByPortIdAndAccess as isInputDeviceConnectedByIdInPipe, isInputDeviceDisconnectedByPortIdAndAccess as isInputDeviceDisconnectedByIdInPipe, isOutputConnectionClosedByPortIdAndAccess as isOutputConnectionClosedByIdInPipe, isOutputConnectionOpenByPortIdAndAccess as isOutputConnectionOpenByIdInPipe, isOutputConnectionPendingByPortIdAndAccess as isOutputConnectionPendingByIdInPipe, isOutputDeviceConnectedByPortIdAndAccess as isOutputDeviceConnectedByIdInPipe, isOutputDeviceDisconnectedByPortIdAndAccess as isOutputDeviceDisconnectedByIdInPipe, isPortConnectionClosedByPortIdAndAccess as isPortConnectionClosedByIdInPipe, isPortConnectionOpenByPortIdAndAccess as isPortConnectionOpenByIdInPipe, isPortConnectionPendingByPortIdAndAccess as isPortConnectionPendingByIdInPipe, isPortDeviceConnectedByPortIdAndAccess as isPortDeviceConnectedByIdInPipe, isPortDeviceDisconnectedByPortIdAndAccess as isPortDeviceDisconnectedByIdInPipe, } from './internal/mutablePropertyTools/doesMutablePortPropertyHaveSpecificValue/doesMutablePortPropertyHaveSpecificValueByPortIdAndAccess.js';
+export { isInputConnectionClosedByPortIdInContext as isInputConnectionClosedById, isInputConnectionOpenByPortIdInContext as isInputConnectionOpenById, isInputConnectionPendingByPortIdInContext as isInputConnectionPendingById, isInputDeviceConnectedByPortIdInContext as isInputDeviceConnectedById, isInputDeviceDisconnectedByPortIdInContext as isInputDeviceDisconnectedById, isOutputConnectionClosedByPortIdInContext as isOutputConnectionClosedById, isOutputConnectionOpenByPortIdInContext as isOutputConnectionOpenById, isOutputConnectionPendingByPortIdInContext as isOutputConnectionPendingById, isOutputDeviceConnectedByPortIdInContext as isOutputDeviceConnectedById, isOutputDeviceDisconnectedByPortIdInContext as isOutputDeviceDisconnectedById, isPortConnectionClosedByPortIdInContext as isPortConnectionClosedById, isPortConnectionOpenByPortIdInContext as isPortConnectionOpenById, isPortConnectionPendingByPortIdInContext as isPortConnectionPendingById, isPortDeviceConnectedByPortIdInContext as isPortDeviceConnectedById, isPortDeviceDisconnectedByPortIdInContext as isPortDeviceDisconnectedById, } from './internal/mutablePropertyTools/doesMutablePortPropertyHaveSpecificValue/doesMutablePortPropertyHaveSpecificValueByPortIdInContext.js';
+// export {
+//   getInputConnectionStateByPort,
+//   getInputDeviceStateByPort,
+//   getOutputConnectionStateByPort,
+//   getOutputDeviceStateByPort,
+//   getPortConnectionStateByPort,
+//   getPortDeviceStateByPort,
+// } from './internal/mutablePropertyTools/getMutablePortProperty/getMutablePortPropertyByPort.ts'
+export { getInputConnectionStateByPortIdAndAccess as getInputConnectionStateByIdInPipe, getInputDeviceStateByPortIdAndAccess as getInputDeviceStateByIdInPipe, getOutputConnectionStateByPortIdAndAccess as getOutputConnectionStateByIdInPipe, getOutputDeviceStateByPortIdAndAccess as getOutputDeviceStateByIdInPipe, getPortConnectionStateByPortIdAndAccess as getPortConnectionStateByIdInPipe, getPortDeviceStateByPortIdAndAccess as getPortDeviceStateByIdInPipe, } from './internal/mutablePropertyTools/getMutablePortProperty/getMutablePortPropertyByPortIdAndAccess.js';
+export { getInputConnectionStateByPortId as getInputConnectionStateById, getInputDeviceStateByPortId as getInputDeviceStateById, getOutputConnectionStateByPortId as getOutputConnectionStateById, getOutputDeviceStateByPortId as getOutputDeviceStateById, getPortConnectionStateByPortId as getPortConnectionStateById, getPortDeviceStateByPortId as getPortDeviceStateById, } from './internal/mutablePropertyTools/getMutablePortProperty/getMutablePortPropertyByPortIdInContext.js';
+// export {
+//   type DualMatchPortState,
+//   type MatcherConfigPlain,
+//   type MatchResult,
+//   type MatchStatePortFirst,
+//   type MatchStatePortLast,
+//   type MIDIPortMutableProperty,
+//   matchInputConnectionStateByPort,
+//   matchInputDeviceStateByPort,
+//   matchOutputConnectionStateByPort,
+//   matchOutputDeviceStateByPort,
+//   matchPortConnectionStateByPort,
+//   matchPortDeviceStateByPort,
+//   type PortStateHandler,
+//   type StateCaseToHandlerMap,
+// } from './internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPort.ts'
+export { matchInputConnectionStateByPortIdAndAccess as matchInputConnectionStateByIdInPipe, matchInputDeviceStateByPortIdAndAccess as matchInputDeviceStateByIdInPipe, matchOutputConnectionStateByPortIdAndAccess as matchOutputConnectionStateByIdInPipe, matchOutputDeviceStateByPortIdAndAccess as matchOutputDeviceStateByIdInPipe, matchPortConnectionStateByPortIdAndAccess as matchPortConnectionStateBydInPipe, matchPortDeviceStateByPortIdAndAccess as matchPortDeviceStateByIdInPipe, } from './internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPortIdAndAccess.js';
+export { matchInputConnectionStateByPortIdInContext as matchInputConnectionStateById, matchInputDeviceStateByPortIdInContext as matchInputDeviceStateById, matchOutputConnectionStateByPortIdInContext as matchOutputConnectionStateById, matchOutputDeviceStateByPortIdInContext as matchOutputDeviceStateById, matchPortConnectionStateByPortIdInContext as matchPortConnectionStateById, matchPortDeviceStateByPortIdInContext as matchPortDeviceStateByPortId, } from './internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPortIdInContext.js';
+//# sourceMappingURL=EMIDIAccess.js.map

package/dist/src/EMIDIAccess.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EMIDIAccess.js","sourceRoot":"","sources":["../../src/EMIDIAccess.ts"],"names":[],"mappings":"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"}

package/dist/src/EMIDIInput.js

@@ -0,0 +1,226 @@
+export { 
+// type AcquiredThing,
+// AllPortsRecord,
+// assert,
+// assumeImpl,
+// clearPortById,
+// type DualSendMIDIMessageFromAccess,
+// EMIDIAccess,
+// type EMIDIAccessInstance,
+// type GetThingByPortId,
+// type GetThingByPortIdAccessFirst,
+// type GetThingByPortIdAccessLast,
+// type GetThingByPortIdAccessLastSecondHalf,
+// getAllPortsRecord,
+getInputsArray as getArray, getInputsRecord as getRecord, 
+// getOutputsRecord,
+InputsArray as Array, InputsRecord as Record, 
+// is,
+// layer,
+// layerMostRestricted,
+// layerSoftwareSynthSupported,
+// layerSystemExclusiveAndSoftwareSynthSupported,
+// layerSystemExclusiveSupported,
+// makeAllPortsStateChangesStream,
+// makeAllPortsStateChangesStreamInContext,
+makeMessagesStreamByInputId as makeMessagesStreamById, makeMessagesStreamByInputIdAndAccess as makeMessagesStreamByIdAndAccess,
+// OutputsRecord,
+// type PolymorphicAccessInstance,
+// type PolymorphicAccessInstanceClean,
+// type RequestMIDIAccessOptions,
+// request,
+// simplify,
+// type SendFromAccessArgs,
+// type SendMIDIMessageAccessFirst,
+// type SendMIDIMessageAccessLast,
+// type SentMessageEffectFromAccess,
+// send,
+// sendInContext,
+// sendToPortById,
+// type TargetPortSelector,
+// type TypeId,
+ } from './internal/EMIDIAccess.js';
+export { 
+// make,
+assert, Id, is, makeMessagesStreamByPort as makeMessagesStream, } from './internal/EMIDIInput.js';
+// export {
+//   assert,
+//   clear,
+//   type DualSendMIDIMessageFromPort,
+//   type EMIDIOutput,
+//   is,
+//   make,
+//   type PolymorphicOutput,
+//   type PolymorphicOutputClean,
+//   type SendFromPortArgs,
+//   type SendMIDIMessagePortFirst,
+//   type SendMIDIMessagePortLast,
+//   type SentMessageEffectFromPort,
+//   send,
+// } from './internal/EMIDIOutput.ts'
+// export {
+//   assert,
+//   assumeImpl,
+//   type EMIDIPort,
+//   type EMIDIPortImpl,
+//   type ExtractTypeFromPort,
+//   is,
+//   isImplOfSpecificType,
+//   makeImpl,
+//   type PolymorphicPort,
+//   type PolymorphicPortClean,
+//   type TypeId,
+// } from './internal/EMIDIPort.ts'
+export { 
+// type GetPortById,
+getInputByPortIdAndAccess as getByIdAndAccess,
+// getOutputByPortIdAndAccess,
+// getPortByPortIdAndAccess,
+ } from './internal/getPortByPortId/getPortByPortIdAndAccess.js';
+export { getInputByPortIdInContext as getById,
+// getOutputByPortIdInContext,
+// getPortByPortIdInContext,
+ } from './internal/getPortByPortId/getPortByPortIdInContext.js';
+export { acquireReleaseInputConnectionByPort as acquireReleaseConnection,
+// acquireReleaseOutputConnectionByPort,
+// acquireReleasePortConnectionByPort,
+ } from './internal/MIDIPortMethodCalls/acquireReleasePortConnection/acquireReleasePortConnectionByPort.js';
+export { acquireReleaseInputConnectionByPortIdAndAccess as acquireReleaseConnectionByIdAndAccess,
+// acquireReleaseOutputConnectionByPortIdAndAccess,
+// acquireReleasePortConnectionByPortIdAndAccess,
+ } from './internal/MIDIPortMethodCalls/acquireReleasePortConnection/acquireReleasePortConnectionByPortIdAndAccess.js';
+export { acquireReleaseInputConnectionByPortIdInContext as acquireReleaseConnectionById,
+// acquireReleaseOutputConnectionByPortIdInContext,
+// acquireReleasePortConnectionByPortIdInContext,
+ } from './internal/MIDIPortMethodCalls/acquireReleasePortConnection/acquireReleasePortConnectionByPortIdInContext.js';
+// export { actOnPort } from './internal/MIDIPortMethodCalls/actOnPort.ts'
+export { closeInputConnectionByPort as closeConnection,
+// closeOutputConnectionByPort,
+// closePortConnectionByPort,
+// makePortConnectionCloser,
+ } from './internal/MIDIPortMethodCalls/closePortConnection/closePortConnectionByPort.js';
+export { closeInputConnectionByPortIdAndAccess as closeConnectionByIdAndAccess,
+// closeOutputConnectionByPortIdAndAccess,
+// closePortConnectionByPortIdAndAccess,
+ } from './internal/MIDIPortMethodCalls/closePortConnection/closePortConnectionByPortIdAndAccess.js';
+export { closeInputConnectionByPortIdInContext as closeConnectionById,
+// closeOutputConnectionByPortIdInContext,
+// closePortConnectionByPortIdInContext,
+ } from './internal/MIDIPortMethodCalls/closePortConnection/closePortConnectionByPortIdInContext.js';
+// export {
+//   makeMIDIPortMethodCallerFactory,
+//   type TouchPort,
+// } from './internal/MIDIPortMethodCalls/makeMIDIPortMethodCallerFactory.ts'
+export { 
+// makePortConnectionOpener,
+openInputConnectionByPort as openConnection,
+// openOutputConnectionByPort,
+// openPortConnectionByPort,
+ } from './internal/MIDIPortMethodCalls/openPortConnection/openPortConnectionByPort.js';
+export { openInputConnectionByPortIdAndAccess as openConnectionByIdAndAccess,
+// openOutputConnectionByPortIdAndAccess,
+// openPortConnectionByPortIdAndAccess,
+ } from './internal/MIDIPortMethodCalls/openPortConnection/openPortConnectionByPortIdAndAccess.js';
+export { openInputConnectionByPortIdInContext as openConnectionById,
+// openOutputConnectionByPortIdInContext,
+// openPortConnectionByPortIdInContext,
+ } from './internal/MIDIPortMethodCalls/openPortConnection/openPortConnectionByPortIdInContext.js';
+export { 
+// type DualMakeStateChangesStream,
+// type MakeStateChangesStreamPortFirst,
+// type MakeStateChangesStreamPortLast,
+makeInputStateChangesStreamByPort as makeStateChangesStream,
+// makeOutputStateChangesStreamByPort,
+// makePortStateChangesStreamByPort,
+// type StateChangesStream,
+ } from './internal/makePortStateChangesStream/makePortStateChangesStreamByPort.js';
+export { makeInputStateChangesStreamByPortIdAndAccess as makeStateChangesStreamByIdAndAccess,
+// makeOutputStateChangesStreamByPortIdAndAccess,
+// makePortStateChangesStreamByPortIdAndAccess,
+ } from './internal/makePortStateChangesStream/makePortStateChangesStreamByPortIdAndAccess.js';
+export { makeInputStateChangesStreamByPortIdInContext as makeStateChangesStreamById,
+// makeOutputStateChangesStreamByPortIdInContext,
+// makePortStateChangesStreamByPortIdInContext,
+ } from './internal/makePortStateChangesStream/makePortStateChangesStreamByPortIdInContext.js';
+export { isInputConnectionClosedByPort as isConnectionClosed, isInputConnectionOpenByPort as isConnectionOpen, isInputConnectionPendingByPort as isConnectionPending, isInputDeviceConnectedByPort as isDeviceConnected, isInputDeviceDisconnectedByPort as isDeviceDisconnected,
+// isOutputConnectionClosedByPort,
+// isOutputConnectionOpenByPort,
+// isOutputConnectionPendingByPort,
+// isOutputDeviceConnectedByPort,
+// isOutputDeviceDisconnectedByPort,
+// isPortConnectionClosedByPort,
+// isPortConnectionOpenByPort,
+// isPortConnectionPendingByPort,
+// isPortDeviceConnectedByPort,
+// isPortDeviceDisconnectedByPort,
+ } from './internal/mutablePropertyTools/doesMutablePortPropertyHaveSpecificValue/doesMutablePortPropertyHaveSpecificValueByPort.js';
+export { isInputConnectionClosedByPortIdAndAccess as isConnectionClosedByIdAndAccess, isInputConnectionOpenByPortIdAndAccess as isConnectionOpenByIdAndAccess, isInputConnectionPendingByPortIdAndAccess as isConnectionPendingByIdAndAccess, isInputDeviceConnectedByPortIdAndAccess as isDeviceConnectedByIdAndAccess, isInputDeviceDisconnectedByPortIdAndAccess as isDeviceDisconnectedByIdAndAccess,
+// isOutputConnectionClosedByPortIdAndAccess,
+// isOutputConnectionOpenByPortIdAndAccess,
+// isOutputConnectionPendingByPortIdAndAccess,
+// isOutputDeviceConnectedByPortIdAndAccess,
+// isOutputDeviceDisconnectedByPortIdAndAccess,
+// isPortConnectionClosedByPortIdAndAccess,
+// isPortConnectionOpenByPortIdAndAccess,
+// isPortConnectionPendingByPortIdAndAccess,
+// isPortDeviceConnectedByPortIdAndAccess,
+// isPortDeviceDisconnectedByPortIdAndAccess,
+ } from './internal/mutablePropertyTools/doesMutablePortPropertyHaveSpecificValue/doesMutablePortPropertyHaveSpecificValueByPortIdAndAccess.js';
+export { isInputConnectionClosedByPortIdInContext as isConnectionClosedById, isInputConnectionOpenByPortIdInContext as isConnectionOpenById, isInputConnectionPendingByPortIdInContext as isConnectionPendingById, isInputDeviceConnectedByPortIdInContext as isDeviceConnectedById, isInputDeviceDisconnectedByPortIdInContext as isDeviceDisconnectedById,
+// isOutputConnectionClosedByPortIdInContext,
+// isOutputConnectionOpenByPortIdInContext,
+// isOutputConnectionPendingByPortIdInContext,
+// isOutputDeviceConnectedByPortIdInContext,
+// isOutputDeviceDisconnectedByPortIdInContext,
+// isPortConnectionClosedByPortIdInContext,
+// isPortConnectionOpenByPortIdInContext,
+// isPortConnectionPendingByPortIdInContext,
+// isPortDeviceConnectedByPortIdInContext,
+// isPortDeviceDisconnectedByPortIdInContext,
+ } from './internal/mutablePropertyTools/doesMutablePortPropertyHaveSpecificValue/doesMutablePortPropertyHaveSpecificValueByPortIdInContext.js';
+export { getInputConnectionStateByPort as getConnectionState, getInputDeviceStateByPort as getDeviceState,
+// getOutputConnectionStateByPort,
+// getOutputDeviceStateByPort,
+// getPortConnectionStateByPort,
+// getPortDeviceStateByPort,
+ } from './internal/mutablePropertyTools/getMutablePortProperty/getMutablePortPropertyByPort.js';
+export { getInputConnectionStateByPortIdAndAccess as getConnectionStateByIdAndAccess, getInputDeviceStateByPortIdAndAccess as getDeviceStateByIdAndAccess,
+// getOutputConnectionStateByPortIdAndAccess,
+// getOutputDeviceStateByPortIdAndAccess,
+// getPortConnectionStateByPortIdAndAccess,
+// getPortDeviceStateByPortIdAndAccess,
+ } from './internal/mutablePropertyTools/getMutablePortProperty/getMutablePortPropertyByPortIdAndAccess.js';
+export { getInputConnectionStateByPortId as getConnectionStateById, getInputDeviceStateByPortId as getDeviceStateById,
+// getOutputConnectionStateByPortId,
+// getOutputDeviceStateByPortId,
+// getPortConnectionStateByPortId,
+// getPortDeviceStateByPortId,
+ } from './internal/mutablePropertyTools/getMutablePortProperty/getMutablePortPropertyByPortIdInContext.js';
+export { 
+// type DualMatchPortState,
+// type MatcherConfigPlain,
+// type MatchResult,
+// type MatchStatePortFirst,
+// type MatchStatePortLast,
+// type MIDIPortMutableProperty,
+matchInputConnectionStateByPort as matchConnectionState, matchInputDeviceStateByPort as matchDeviceState,
+// matchOutputConnectionStateByPort,
+// matchOutputDeviceStateByPort,
+// matchPortConnectionStateByPort,
+// matchPortDeviceStateByPort,
+// type PortStateHandler,
+// type StateCaseToHandlerMap,
+ } from './internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPort.js';
+export { matchInputConnectionStateByPortIdAndAccess as matchConnectionStateByIdAndAccess, matchInputDeviceStateByPortIdAndAccess as matchDeviceStateByIdAndAccess,
+// matchOutputConnectionStateByPortIdAndAccess,
+// matchOutputDeviceStateByPortIdAndAccess,
+// matchPortConnectionStateByPortIdAndAccess,
+// matchPortDeviceStateByPortIdAndAccess,
+ } from './internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPortIdAndAccess.js';
+export { matchInputConnectionStateByPortIdInContext as matchConnectionStateById, matchInputDeviceStateByPortIdInContext as matchDeviceStateById,
+// matchOutputConnectionStateByPortIdInContext,
+// matchOutputDeviceStateByPortIdInContext,
+// matchPortConnectionStateByPortIdInContext,
+// matchPortDeviceStateByPortIdInContext,
+ } from './internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPortIdInContext.js';
+//# sourceMappingURL=EMIDIInput.js.map