effect-web-midi 0.1.0

package/dist-types/src/internal/mutablePropertyTools/getMutablePortProperty/getMutablePortPropertyByPortIdInContext.d.ts

@@ -0,0 +1,17 @@
+import * as EMIDIAccess from '../../EMIDIAccess.ts';
+import type * as EMIDIPort from '../../EMIDIPort.ts';
+/**
+ *
+ *
+ */
+export declare const getPortDeviceStateByPortId: (id: EMIDIPort.BothId) => import("effect/Effect").Effect<MIDIPortDeviceState, never, EMIDIAccess.EMIDIAccess>;
+/**
+ *
+ *
+ */
+export declare const getPortConnectionStateByPortId: (id: EMIDIPort.BothId) => import("effect/Effect").Effect<MIDIPortConnectionState, import("../../errors.ts").PortNotFoundError, EMIDIAccess.EMIDIAccess>;
+export declare const getInputConnectionStateByPortId: () => never;
+export declare const getInputDeviceStateByPortId: () => never;
+export declare const getOutputConnectionStateByPortId: () => never;
+export declare const getOutputDeviceStateByPortId: () => never;
+//# sourceMappingURL=getMutablePortPropertyByPortIdInContext.d.ts.map

package/dist-types/src/internal/mutablePropertyTools/getMutablePortProperty/getMutablePortPropertyByPortIdInContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMutablePortPropertyByPortIdInContext.d.ts","sourceRoot":"","sources":["../../../../../src/internal/mutablePropertyTools/getMutablePortProperty/getMutablePortPropertyByPortIdInContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,sBAAsB,CAAA;AACnD,OAAO,KAAK,KAAK,SAAS,MAAM,oBAAoB,CAAA;AAGpD;;;GAGG;AACH,eAAO,MAAM,0BAA0B,GAAI,IAAI,SAAS,CAAC,MAAM,wFACO,CAAA;AAEtE;;;GAGG;AACH,eAAO,MAAM,8BAA8B,GAAI,IAAI,SAAS,CAAC,MAAM,kIACO,CAAA;AAG1E,eAAO,MAAM,+BAA+B,aAE3C,CAAA;AAGD,eAAO,MAAM,2BAA2B,aAEvC,CAAA;AAGD,eAAO,MAAM,gCAAgC,aAE5C,CAAA;AAGD,eAAO,MAAM,4BAA4B,aAExC,CAAA"}

package/dist-types/src/internal/mutablePropertyTools/getValueInRawPortFieldUnsafe.d.ts

@@ -0,0 +1,7 @@
+import * as EMIDIPort from '../EMIDIPort.ts';
+import type { MIDIPortMutableProperty } from './matchMutablePortProperty/matchMutablePortPropertyByPort.ts';
+/**
+ * @internal
+ */
+export declare const getValueInRawPortFieldUnsafe: <const TMIDIPortMutableProperty extends MIDIPortMutableProperty>(property: TMIDIPortMutableProperty) => (port: EMIDIPort.EMIDIPort) => MIDIPort[TMIDIPortMutableProperty];
+//# sourceMappingURL=getValueInRawPortFieldUnsafe.d.ts.map

package/dist-types/src/internal/mutablePropertyTools/getValueInRawPortFieldUnsafe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getValueInRawPortFieldUnsafe.d.ts","sourceRoot":"","sources":["../../../../src/internal/mutablePropertyTools/getValueInRawPortFieldUnsafe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,iBAAiB,CAAA;AAC5C,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,8DAA8D,CAAA;AAE3G;;GAEG;AACH,eAAO,MAAM,4BAA4B,GACtC,KAAK,CAAC,wBAAwB,SAAS,uBAAuB,EAC7D,UAAU,wBAAwB,MAEnC,MAAM,SAAS,CAAC,SAAS,uCACkB,CAAA"}

package/dist-types/src/internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPort.d.ts

@@ -0,0 +1,71 @@
+/** 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 EMIDIPort from '../../EMIDIPort.ts';
+/**
+ *
+ */
+export declare const matchPortConnectionStateByPort: DualMatchPortState<MIDIPortType, "connection">;
+/**
+ *
+ */
+export declare const matchPortDeviceStateByPort: DualMatchPortState<MIDIPortType, "state">;
+/**
+ *
+ */
+export declare const matchInputConnectionStateByPort: DualMatchPortState<"input", "connection">;
+/**
+ *
+ */
+export declare const matchInputDeviceStateByPort: DualMatchPortState<"input", "state">;
+/**
+ *
+ */
+export declare const matchOutputConnectionStateByPort: DualMatchPortState<"output", "connection">;
+/**
+ *
+ */
+export declare const matchOutputDeviceStateByPort: DualMatchPortState<"output", "state">;
+export type MIDIPortMutableProperty = 'state' | 'connection';
+export interface PortStateHandler {
+    (port: EMIDIPort.EMIDIPort): any;
+}
+export interface MatcherConfigPlain extends Record<string, PortStateHandler> {
+}
+export interface MatchResult<TActualConf extends MatcherConfigPlain, E, R> extends Effect.Effect<ReturnType<TActualConf[keyof TActualConf]>, E, R> {
+}
+export interface DualMatchPortState<THighLevelPortType extends MIDIPortType, TMIDIPortProperty extends MIDIPortMutableProperty> extends MatchStatePortLast<THighLevelPortType, TMIDIPortProperty>, MatchStatePortFirst<THighLevelPortType, TMIDIPortProperty> {
+}
+export interface MatchStatePortFirst<THighLevelPortType extends MIDIPortType, TMIDIPortProperty extends MIDIPortMutableProperty> {
+    /**
+     * Description placeholder
+     *
+     * @param polymorphicPort
+     * @param stateCaseToHandlerMap
+     * @returns
+     */
+    <TStateCaseToHandlerMap extends StateCaseToHandlerMap<TMIDIPortProperty, THighLevelPortType, TStateCaseToHandlerMap>, E = never, R = never>(polymorphicPort: EMIDIPort.PolymorphicPort<E, R, THighLevelPortType>, stateCaseToHandlerMap: TStateCaseToHandlerMap): MatchResult<TStateCaseToHandlerMap, E, R>;
+}
+export interface MatchStatePortLast<THighLevelPortType extends MIDIPortType, TMIDIPortProperty extends MIDIPortMutableProperty> {
+    /**
+     * Description placeholder
+     *
+     * @param stateCaseToHandlerMap
+     * @returns
+     */
+    <TStateCaseToHandlerMap extends StateCaseToHandlerMap<TMIDIPortProperty, THighLevelPortType, TStateCaseToHandlerMap>>(stateCaseToHandlerMap: TStateCaseToHandlerMap): {
+        /**
+         * Description placeholder
+         *
+         * @param polymorphicPort
+         * @returns
+         */
+        <E = never, R = never>(polymorphicPort: EMIDIPort.PolymorphicPort<E, R, THighLevelPortType>): MatchResult<TStateCaseToHandlerMap, E, R>;
+    };
+}
+export type StateCaseToHandlerMap<TMIDIPortProperty extends MIDIPortMutableProperty, TMIDIPortType extends MIDIPortType, TConfigSelf> = {
+    readonly [StateCase in MIDIPort[TMIDIPortProperty]]: (port: EMIDIPort.EMIDIPort<TMIDIPortType>) => any;
+} & {
+    readonly [RedundantValueCaseHandling in Exclude<keyof TConfigSelf, MIDIPort[TMIDIPortProperty]>]: never;
+};
+//# sourceMappingURL=matchMutablePortPropertyByPort.d.ts.map

package/dist-types/src/internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchMutablePortPropertyByPort.d.ts","sourceRoot":"","sources":["../../../../../src/internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPort.ts"],"names":[],"mappings":"AAAA;gEACgE;AAEhE,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAKvC,OAAO,KAAK,SAAS,MAAM,oBAAoB,CAAA;AAuC/C;;GAEG;AACH,eAAO,MAAM,8BAA8B,gDAG1C,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,0BAA0B,2CAGtC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,+BAA+B,2CAG3C,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,2BAA2B,sCAGvC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,gCAAgC,4CAG5C,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,4BAA4B,uCAGxC,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG,OAAO,GAAG,YAAY,CAAA;AAE5D,MAAM,WAAW,gBAAgB;IAE/B,CAAC,IAAI,EAAE,SAAS,CAAC,SAAS,GAAG,GAAG,CAAA;CACjC;AACD,MAAM,WAAW,kBAAmB,SAAQ,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC;CAAG;AAE/E,MAAM,WAAW,WAAW,CAAC,WAAW,SAAS,kBAAkB,EAAE,CAAC,EAAE,CAAC,CACvE,SAAQ,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,WAAW,CAAC,MAAM,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;CAAG;AAE5E,MAAM,WAAW,kBAAkB,CACjC,kBAAkB,SAAS,YAAY,EACvC,iBAAiB,SAAS,uBAAuB,CACjD,SAAQ,kBAAkB,CAAC,kBAAkB,EAAE,iBAAiB,CAAC,EAC/D,mBAAmB,CAAC,kBAAkB,EAAE,iBAAiB,CAAC;CAAG;AAEjE,MAAM,WAAW,mBAAmB,CAClC,kBAAkB,SAAS,YAAY,EACvC,iBAAiB,SAAS,uBAAuB;IAEjD;;;;;;OAMG;IACH,CACE,sBAAsB,SAAS,qBAAqB,CAClD,iBAAiB,EACjB,kBAAkB,EAClB,sBAAsB,CACvB,EACD,CAAC,GAAG,KAAK,EACT,CAAC,GAAG,KAAK,EAET,eAAe,EAAE,SAAS,CAAC,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,kBAAkB,CAAC,EACpE,qBAAqB,EAAE,sBAAsB,GAC5C,WAAW,CAAC,sBAAsB,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;CAC7C;AAED,MAAM,WAAW,kBAAkB,CACjC,kBAAkB,SAAS,YAAY,EACvC,iBAAiB,SAAS,uBAAuB;IAEjD;;;;;OAKG;IACH,CACE,sBAAsB,SAAS,qBAAqB,CAClD,iBAAiB,EACjB,kBAAkB,EAClB,sBAAsB,CACvB,EAED,qBAAqB,EAAE,sBAAsB,GAC5C;QACD;;;;;WAKG;QACH,CAAC,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,EACnB,eAAe,EAAE,SAAS,CAAC,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,kBAAkB,CAAC,GACnE,WAAW,CAAC,sBAAsB,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;KAC7C,CAAA;CACF;AAED,MAAM,MAAM,qBAAqB,CAC/B,iBAAiB,SAAS,uBAAuB,EACjD,aAAa,SAAS,YAAY,EAClC,WAAW,IACT;IACF,QAAQ,EAAE,SAAS,IAAI,QAAQ,CAAC,iBAAiB,CAAC,GAAG,CACnD,IAAI,EAAE,SAAS,CAAC,SAAS,CAAC,aAAa,CAAC,KAErC,GAAG;CACT,GAAG;IACF,QAAQ,EAAE,0BAA0B,IAAI,OAAO,CAC7C,MAAM,WAAW,EACjB,QAAQ,CAAC,iBAAiB,CAAC,CAC5B,GAAG,KAAK;CACV,CAAA"}

package/dist-types/src/internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPortIdAndAccess.d.ts

@@ -0,0 +1,7 @@
+export declare const matchInputConnectionStateByPortIdAndAccess: () => never;
+export declare const matchInputDeviceStateByPortIdAndAccess: () => never;
+export declare const matchOutputConnectionStateByPortIdAndAccess: () => never;
+export declare const matchOutputDeviceStateByPortIdAndAccess: () => never;
+export declare const matchPortConnectionStateByPortIdAndAccess: () => never;
+export declare const matchPortDeviceStateByPortIdAndAccess: () => never;
+//# sourceMappingURL=matchMutablePortPropertyByPortIdAndAccess.d.ts.map

package/dist-types/src/internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPortIdAndAccess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchMutablePortPropertyByPortIdAndAccess.d.ts","sourceRoot":"","sources":["../../../../../src/internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPortIdAndAccess.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,0CAA0C,aAEtD,CAAA;AAGD,eAAO,MAAM,sCAAsC,aAElD,CAAA;AAGD,eAAO,MAAM,2CAA2C,aAEvD,CAAA;AAGD,eAAO,MAAM,uCAAuC,aAEnD,CAAA;AAGD,eAAO,MAAM,yCAAyC,aAErD,CAAA;AAGD,eAAO,MAAM,qCAAqC,aAEjD,CAAA"}

package/dist-types/src/internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPortIdInContext.d.ts

@@ -0,0 +1,28 @@
+import type * as EMIDIAccess from '../../EMIDIAccess.ts';
+import type * as Errors from '../../errors.ts';
+import * as Match from './matchMutablePortPropertyByPort.ts';
+/**
+ *
+ */
+export declare const matchPortConnectionStateByPortIdInContext: <TStateCaseToHandlerMap extends Match.StateCaseToHandlerMap<"connection", MIDIPortType, TStateCaseToHandlerMap>>(id: (string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"input">) | (string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"output">), stateCaseToHandlerMap: TStateCaseToHandlerMap) => Match.MatchResult<TStateCaseToHandlerMap, Errors.PortNotFoundError, EMIDIAccess.EMIDIAccess>;
+/**
+ *
+ */
+export declare const matchInputConnectionStateByPortIdInContext: <TStateCaseToHandlerMap extends Match.StateCaseToHandlerMap<"connection", "input", TStateCaseToHandlerMap>>(id: string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"input">, stateCaseToHandlerMap: TStateCaseToHandlerMap) => Match.MatchResult<TStateCaseToHandlerMap, Errors.PortNotFoundError, EMIDIAccess.EMIDIAccess>;
+/**
+ *
+ */
+export declare const matchOutputConnectionStateByPortIdInContext: <TStateCaseToHandlerMap extends Match.StateCaseToHandlerMap<"connection", "output", TStateCaseToHandlerMap>>(id: string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"output">, stateCaseToHandlerMap: TStateCaseToHandlerMap) => Match.MatchResult<TStateCaseToHandlerMap, Errors.PortNotFoundError, EMIDIAccess.EMIDIAccess>;
+/**
+ *
+ */
+export declare const matchPortDeviceStateByPortIdInContext: <TStateCaseToHandlerMap extends Match.StateCaseToHandlerMap<"state", MIDIPortType, TStateCaseToHandlerMap>>(id: (string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"input">) | (string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"output">), stateCaseToHandlerMap: TStateCaseToHandlerMap) => Match.MatchResult<TStateCaseToHandlerMap, Errors.PortNotFoundError, EMIDIAccess.EMIDIAccess>;
+/**
+ *
+ */
+export declare const matchInputDeviceStateByPortIdInContext: <TStateCaseToHandlerMap extends Match.StateCaseToHandlerMap<"state", "input", TStateCaseToHandlerMap>>(id: string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"input">, stateCaseToHandlerMap: TStateCaseToHandlerMap) => Match.MatchResult<TStateCaseToHandlerMap, Errors.PortNotFoundError, EMIDIAccess.EMIDIAccess>;
+/**
+ *
+ */
+export declare const matchOutputDeviceStateByPortIdInContext: <TStateCaseToHandlerMap extends Match.StateCaseToHandlerMap<"state", "output", TStateCaseToHandlerMap>>(id: string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"output">, stateCaseToHandlerMap: TStateCaseToHandlerMap) => Match.MatchResult<TStateCaseToHandlerMap, Errors.PortNotFoundError, EMIDIAccess.EMIDIAccess>;
+//# sourceMappingURL=matchMutablePortPropertyByPortIdInContext.d.ts.map

package/dist-types/src/internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPortIdInContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchMutablePortPropertyByPortIdInContext.d.ts","sourceRoot":"","sources":["../../../../../src/internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPortIdInContext.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,WAAW,MAAM,sBAAsB,CAAA;AAExD,OAAO,KAAK,KAAK,MAAM,MAAM,iBAAiB,CAAA;AAE9C,OAAO,KAAK,KAAK,MAAM,qCAAqC,CAAA;AA+B5D;;GAEG;AACH,eAAO,MAAM,yCAAyC,GAdlD,sBAAsB,4aAkBvB,CAAA;AAEH;;GAEG;AACH,eAAO,MAAM,0CAA0C,GAvBnD,sBAAsB,oUA2BvB,CAAA;AAEH;;GAEG;AACH,eAAO,MAAM,2CAA2C,GAhCpD,sBAAsB,sUAoCvB,CAAA;AAEH;;GAEG;AACH,eAAO,MAAM,qCAAqC,GAzC9C,sBAAsB,uaA4CzB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,sCAAsC,GAjD/C,sBAAsB,+TAoDzB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,uCAAuC,GAzDhD,sBAAsB,iUA4DzB,CAAA"}

package/dist-types/src/internal/parsing.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @file This module is not for general use, these are just helpers to test the
+ * MIDI API with the only MIDI device I have: nanoPAD v1
+ */
+import * as Stream from 'effect/Stream';
+/**
+ *
+ * @param self
+ * @returns
+ */
+export declare const withParsedDataField: <A extends {
+    readonly midiMessage: Uint8Array<ArrayBuffer>;
+}, E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<Omit<A, "midiMessage"> & {
+    readonly midiMessage: ParsedMIDIMessages;
+}, E, R>;
+/**
+ *
+ * @param self
+ * @returns
+ */
+export declare const withTouchpadPositionUpdates: <A extends {
+    midiMessage: ControlChange | TouchpadRelease | PitchBendChange | {
+        _tag: string & {};
+    };
+}, E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A | (Omit<A, "midiMessage"> & {
+    readonly midiMessage: TouchpadPositionUpdate;
+}), E, R>;
+export type ParsedMIDIMessages = NoteRelease | NotePress | UnknownReply | ControlChange | TouchpadRelease | PitchBendChange;
+export interface NoteRelease extends Readonly<{
+    _tag: 'Note Release';
+    channel: number;
+    note: number;
+}> {
+}
+export interface NotePress extends Readonly<{
+    _tag: 'Note Press';
+    channel: number;
+    note: number;
+    velocity: number;
+}> {
+}
+export interface UnknownReply extends Readonly<{
+    _tag: 'Unknown Reply';
+    unexpectedData: string;
+    stack: string;
+}> {
+}
+export interface ControlChange extends Readonly<{
+    _tag: 'Control Change';
+    channel: number;
+    control: number;
+    value: number;
+}> {
+}
+export interface TouchpadRelease extends Readonly<{
+    _tag: 'Touchpad Release';
+    channel: number;
+}> {
+}
+export interface PitchBendChange extends Readonly<{
+    _tag: 'Pitch Bend Change';
+    channel: number;
+    value: number;
+}> {
+}
+export interface TouchpadPositionUpdate extends Readonly<{
+    _tag: 'Touchpad Position Update';
+    x: number;
+    y: number;
+}> {
+}
+//# sourceMappingURL=parsing.d.ts.map

package/dist-types/src/internal/parsing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsing.d.ts","sourceRoot":"","sources":["../../../src/internal/parsing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAKvC;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAC9B,CAAC,SAAS;IAAE,QAAQ,CAAC,WAAW,EAAE,UAAU,CAAC,WAAW,CAAC,CAAA;CAAE,EAC3D,CAAC,EACD,CAAC,EAED,MAAM,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAKrB,MAAM,CAAC,MAAM,CAClB,IAAI,CAAC,CAAC,EAAE,aAAa,CAAC,GAAG;IAAE,QAAQ,CAAC,WAAW,EAAE,kBAAkB,CAAA;CAAE,EACrE,CAAC,EACD,CAAC,CACF,CAAA;AAEH;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,GACtC,CAAC,SAAS;IACR,WAAW,EACP,aAAa,GACb,eAAe,GACf,eAAe,GACf;QAAE,IAAI,EAAE,MAAM,GAAG,EAAE,CAAA;KAAE,CAAA;CAC1B,EACD,CAAC,EACD,CAAC,EAED,MAAM,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAC3B,MAAM,CAAC,MAAM,CACZ,CAAC,GACD,CAAC,IAAI,CAAC,CAAC,EAAE,aAAa,CAAC,GAAG;IAAE,QAAQ,CAAC,WAAW,EAAE,sBAAsB,CAAA;CAAE,CAAC,EAC7E,CAAC,EACD,CAAC,CAuCuB,CAAA;AAE1B,MAAM,MAAM,kBAAkB,GAC1B,WAAW,GACX,SAAS,GACT,YAAY,GACZ,aAAa,GACb,eAAe,GACf,eAAe,CAAA;AA8EnB,MAAM,WAAW,WACf,SAAQ,QAAQ,CAAC;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;CAAG;AAE9E,MAAM,WAAW,SACf,SAAQ,QAAQ,CAAC;IACf,IAAI,EAAE,YAAY,CAAA;IAClB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAC;CAAG;AAEP,MAAM,WAAW,YACf,SAAQ,QAAQ,CAAC;IACf,IAAI,EAAE,eAAe,CAAA;IACrB,cAAc,EAAE,MAAM,CAAA;IACtB,KAAK,EAAE,MAAM,CAAA;CACd,CAAC;CAAG;AAEP,MAAM,WAAW,aACf,SAAQ,QAAQ,CAAC;IACf,IAAI,EAAE,gBAAgB,CAAA;IACtB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;CACd,CAAC;CAAG;AAEP,MAAM,WAAW,eACf,SAAQ,QAAQ,CAAC;IAAE,IAAI,EAAE,kBAAkB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;CAAG;AAEpE,MAAM,WAAW,eACf,SAAQ,QAAQ,CAAC;IACf,IAAI,EAAE,mBAAmB,CAAA;IACzB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;CACd,CAAC;CAAG;AAEP,MAAM,WAAW,sBACf,SAAQ,QAAQ,CAAC;IACf,IAAI,EAAE,0BAA0B,CAAA;IAChC,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV,CAAC;CAAG"}

package/dist-types/src/internal/util.d.ts

@@ -0,0 +1,33 @@
+import type * as Brand from 'effect/Brand';
+import * as Effect from 'effect/Effect';
+import * as Stream from 'effect/Stream';
+import type * as Errors from './errors.ts';
+export declare const midiPortStaticFields: readonly ["id", "name", "manufacturer", "version", "type"];
+export type MIDIPortStaticFields = (typeof midiPortStaticFields)[number];
+export declare const getStaticMIDIPortInfo: (port: Pick<MIDIPort, MIDIPortStaticFields>) => {
+    readonly name: string | null;
+    readonly id: string;
+    readonly manufacturer: string | null;
+    readonly version: string | null;
+    readonly type: MIDIPortType;
+};
+/**
+ * Puts Self into success channel for easier chaining of operations on the same
+ * entity
+ */
+export interface SentMessageEffectFrom<Self, E = never, R = never> extends Effect.Effect<Self, E | Errors.CantSendSysexMessagesError | Errors.MalformedMidiMessageError | Errors.DisconnectedPortError, R> {
+}
+export type PolymorphicEffect<A, E, R> = A | Effect.Effect<A, E, R>;
+export type FallbackOnUnknownOrAny<TCandidate, Fallback> = unknown extends TCandidate ? TCandidate extends unknown ? Fallback : TCandidate : TCandidate;
+export declare const polymorphicCheckInDual: (is: (arg: unknown) => boolean) => (arg: IArguments) => boolean;
+export declare function fromPolymorphic<A, E = never, R = never>(polymorphicValue: PolymorphicEffect<A, E, R>, is: (arg: unknown) => arg is NoInfer<A>): Effect.Effect<A, E, R>;
+export type IsEqualFlag<TPropertyName extends string, TExpectedValue extends string> = boolean & Brand.Brand<TPropertyName> & Brand.Brand<`expectedValue: ${TExpectedValue}`>;
+export declare const isCertainDeviceState: <const TExpectedValue extends MIDIPortDeviceState>(expected: TExpectedValue) => <E, R>(self: Effect.Effect<MIDIPortDeviceState, E, R>) => Effect.Effect<IsEqualFlag<"isCertainDeviceState", TExpectedValue>, E, R>;
+export declare const isCertainConnectionState: <const TExpectedValue extends MIDIPortConnectionState>(expected: TExpectedValue) => <E, R>(self: Effect.Effect<MIDIPortConnectionState, E, R>) => Effect.Effect<IsEqualFlag<"isCertainConnectionState", TExpectedValue>, E, R>;
+export declare const isDeviceConnected: <E, R>(self: Effect.Effect<MIDIPortDeviceState, E, R>) => Effect.Effect<IsEqualFlag<"isCertainDeviceState", "connected">, E, R>;
+export declare const isDeviceDisconnected: <E, R>(self: Effect.Effect<MIDIPortDeviceState, E, R>) => Effect.Effect<IsEqualFlag<"isCertainDeviceState", "disconnected">, E, R>;
+export declare const isConnectionOpen: <E, R>(self: Effect.Effect<MIDIPortConnectionState, E, R>) => Effect.Effect<IsEqualFlag<"isCertainConnectionState", "open">, E, R>;
+export declare const isConnectionPending: <E, R>(self: Effect.Effect<MIDIPortConnectionState, E, R>) => Effect.Effect<IsEqualFlag<"isCertainConnectionState", "pending">, E, R>;
+export declare const isConnectionClosed: <E, R>(self: Effect.Effect<MIDIPortConnectionState, E, R>) => Effect.Effect<IsEqualFlag<"isCertainConnectionState", "closed">, E, R>;
+export declare const mapToGlidingStringLogOfLimitedEntriesCount: <A>(windowSize: number, show: "latestFirst" | "oldestFirst", objectify: (current: NoInfer<A>) => object) => <E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<string, E, R>;
+//# sourceMappingURL=util.d.ts.map

package/dist-types/src/internal/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../src/internal/util.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,KAAK,MAAM,MAAM,aAAa,CAAA;AAE1C,eAAO,MAAM,oBAAoB,4DAMvB,CAAA;AAEV,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAA;AAExE,eAAO,MAAM,qBAAqB,GAChC,MAAM,IAAI,CAAC,QAAQ,EAAE,oBAAoB,CAAC;;;;;;CACG,CAAA;AAE/C;;;GAGG;AACH,MAAM,WAAW,qBAAqB,CAAC,IAAI,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,CAC/D,SAAQ,MAAM,CAAC,MAAM,CACnB,IAAI,EACF,CAAC,GACD,MAAM,CAAC,0BAA0B,GACjC,MAAM,CAAC,yBAAyB,GAChC,MAAM,CAAC,qBAAqB,EAC9B,CAAC,CACF;CAAG;AAEN,MAAM,MAAM,iBAAiB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;AAEnE,MAAM,MAAM,sBAAsB,CAAC,UAAU,EAAE,QAAQ,IACrD,OAAO,SAAS,UAAU,GACtB,UAAU,SAAS,OAAO,GACxB,QAAQ,GACR,UAAU,GACZ,UAAU,CAAA;AAEhB,eAAO,MAAM,sBAAsB,GAChC,IAAI,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,MAAM,KAAK,UAAU,YACZ,CAAA;AAEzC,wBAAgB,eAAe,CAAC,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,EACrD,gBAAgB,EAAE,iBAAiB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAC5C,EAAE,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,GAAG,IAAI,OAAO,CAAC,CAAC,CAAC,0BAUxC;AAeD,MAAM,MAAM,WAAW,CACrB,aAAa,SAAS,MAAM,EAC5B,cAAc,SAAS,MAAM,IAC3B,OAAO,GACT,KAAK,CAAC,KAAK,CAAC,aAAa,CAAC,GAC1B,KAAK,CAAC,KAAK,CAAC,kBAAkB,cAAc,EAAE,CAAC,CAAA;AAEjD,eAAO,MAAM,oBAAoB,SAfxB,cAAc,4DACpB,CAAC,EAAE,CAAC,EAAE,8CAAqC,6EAiB3C,CAAA;AAEH,eAAO,MAAM,wBAAwB,SApB5B,cAAc,gEACpB,CAAC,EAAE,CAAC,EAAE,kDAAqC,iFAsB3C,CAAA;AAEH,eAAO,MAAM,iBAAiB,GAxB3B,CAAC,EAAE,CAAC,0HAwB2D,CAAA;AAClE,eAAO,MAAM,oBAAoB,GAzB9B,CAAC,EAAE,CAAC,6HAyBiE,CAAA;AAExE,eAAO,MAAM,gBAAgB,GA3B1B,CAAC,EAAE,CAAC,6HA2ByD,CAAA;AAChE,eAAO,MAAM,mBAAmB,GA5B7B,CAAC,EAAE,CAAC,gIA4B+D,CAAA;AACtE,eAAO,MAAM,kBAAkB,GA7B5B,CAAC,EAAE,CAAC,+HA6B6D,CAAA;AAEpE,eAAO,MAAM,0CAA0C,GACpD,CAAC,EACA,YAAY,MAAM,EAClB,MAAM,aAAa,GAAG,aAAa,EACnC,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,MAAM,MAE3C,CAAC,EAAE,CAAC,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,gCA4ClC,CAAA"}

package/index.ts

@@ -0,0 +1 @@
+export * from './src/index.ts'

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "effect-web-midi",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Effect WEB MIDI",
+  "license": "MIT",
+  "scripts": {
+    "build": "tspc",
+    "dev": "tspc --watch"
+  },
+  "files": [
+    ".github/FUNDING.yml",
+    "dist-types",
+    "dist",
+    "index.ts",
+    "package.json",
+    "src",
+    "!**/*.spec.*",
+    "!**/*.tsbuildinfo",
+    "!**/scratchpad.*"
+  ],
+  "dependencies": {
+    "effect": "catalog:"
+  },
+  "homepage": "https://github.com/nikelborm/effect-garden/tree/main/packages/effect-web-midi",
+  "devDependencies": {
+    "@effect/language-service": "catalog:",
+    "@nikelborm/tsconfig": "workspace:*",
+    "ts-namespace-import": "catalog:",
+    "ts-patch": "catalog:",
+    "typescript": "catalog:"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": false
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/nikelborm/effect-garden.git"
+  },
+  "bugs": {
+    "url": "https://github.com/nikelborm/effect-garden/issues",
+    "email": "evadev@duck.com"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist-types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist-types/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./*.js": {
+      "types": "./dist-types/src/*.d.ts",
+      "default": "./dist/src/*.js"
+    },
+    "./*.ts": "./src/*.ts",
+    "./*": {
+      "types": "./dist-types/src/*.d.ts",
+      "default": "./dist/src/*.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "author": {
+    "name": "nikelborm",
+    "email": "evadev@duck.com",
+    "url": "https://github.com/nikelborm"
+  },
+  "contributors": [
+    {
+      "name": "nikelborm",
+      "email": "evadev@duck.com",
+      "url": "https://github.com/nikelborm"
+    }
+  ],
+  "maintainers": [
+    {
+      "name": "nikelborm",
+      "email": "evadev@duck.com",
+      "url": "https://github.com/nikelborm"
+    }
+  ]
+}

package/src/EMIDIAccess.ts

@@ -0,0 +1,271 @@
+export {
+  type AcquiredThing,
+  AllPortsRecord,
+  assert,
+  // assumeImpl,
+  clearPortById,
+  type DualSendMIDIMessageFromAccess,
+  EMIDIAccess,
+  type EMIDIAccessInstance,
+  type GetThingByPortId,
+  type GetThingByPortIdAccessFirst,
+  type GetThingByPortIdAccessLast,
+  type GetThingByPortIdAccessLastSecondHalf,
+  getAllPortsRecord,
+  getInputsRecord,
+  getOutputsRecord,
+  InputsRecord,
+  is,
+  layer,
+  layerMostRestricted,
+  layerSoftwareSynthSupported,
+  layerSystemExclusiveAndSoftwareSynthSupported,
+  layerSystemExclusiveSupported,
+  makeAllPortsStateChangesStream,
+  makeAllPortsStateChangesStreamInContext,
+  makeMessagesStreamByInputId,
+  makeMessagesStreamByInputIdAndAccess,
+  OutputsRecord,
+  type PolymorphicAccessInstance,
+  type PolymorphicAccessInstanceClean,
+  type RequestMIDIAccessOptions,
+  request,
+  // resolve,
+  type SendFromAccessArgs,
+  type SendMIDIMessageAccessFirst,
+  type SendMIDIMessageAccessLast,
+  type SentMessageEffectFromAccess,
+  send,
+  sendInContext,
+  sendToPortById,
+  type TargetPortSelector,
+  type TypeId,
+} from './internal/EMIDIAccess.ts'
+// 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 {
+  type GetPortById,
+  getInputByPortIdAndAccess as getInputByIdInPipe,
+  getOutputByPortIdAndAccess as getOutputByIdInPipe,
+  getPortByPortIdAndAccess as getPortByIdInPipe,
+} from './internal/getPortByPortId/getPortByPortIdAndAccess.ts'
+export {
+  getInputByPortIdInContext as getInputById,
+  getOutputByPortIdInContext as getOutputById,
+  getPortByPortIdInContext as getPortById,
+} from './internal/getPortByPortId/getPortByPortIdInContext.ts'
+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.ts'
+export {
+  acquireReleaseInputConnectionByPortIdInContext as acquireReleaseInputConnectionById,
+  acquireReleaseOutputConnectionByPortIdInContext as acquireReleaseOutputConnectionById,
+  acquireReleasePortConnectionByPortIdInContext as acquireReleasePortConnectionById,
+} from './internal/MIDIPortMethodCalls/acquireReleasePortConnection/acquireReleasePortConnectionByPortIdInContext.ts'
+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.ts'
+export {
+  closeInputConnectionByPortIdInContext as closeInputConnectionById,
+  closeOutputConnectionByPortIdInContext as closeOutputConnectionById,
+  closePortConnectionByPortIdInContext as closePortConnectionById,
+} from './internal/MIDIPortMethodCalls/closePortConnection/closePortConnectionByPortIdInContext.ts'
+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.ts'
+export {
+  openInputConnectionByPortIdInContext as openInputConnectionById,
+  openOutputConnectionByPortIdInContext as openOutputConnectionById,
+  openPortConnectionByPortIdInContext as openPortConnectionById,
+} from './internal/MIDIPortMethodCalls/openPortConnection/openPortConnectionByPortIdInContext.ts'
+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.ts'
+export {
+  makeInputStateChangesStreamByPortIdInContext as makeInputStateChangesStreamById,
+  makeOutputStateChangesStreamByPortIdInContext as makeOutputStateChangesStreamById,
+  makePortStateChangesStreamByPortIdInContext as makePortStateChangesStreamById,
+} from './internal/makePortStateChangesStream/makePortStateChangesStreamByPortIdInContext.ts'
+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.ts'
+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.ts'
+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.ts'
+export {
+  getInputConnectionStateByPortId as getInputConnectionStateById,
+  getInputDeviceStateByPortId as getInputDeviceStateById,
+  getOutputConnectionStateByPortId as getOutputConnectionStateById,
+  getOutputDeviceStateByPortId as getOutputDeviceStateById,
+  getPortConnectionStateByPortId as getPortConnectionStateById,
+  getPortDeviceStateByPortId as getPortDeviceStateById,
+} from './internal/mutablePropertyTools/getMutablePortProperty/getMutablePortPropertyByPortIdInContext.ts'
+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.ts'
+export {
+  matchInputConnectionStateByPortIdInContext as matchInputConnectionStateById,
+  matchInputDeviceStateByPortIdInContext as matchInputDeviceStateById,
+  matchOutputConnectionStateByPortIdInContext as matchOutputConnectionStateById,
+  matchOutputDeviceStateByPortIdInContext as matchOutputDeviceStateById,
+  matchPortConnectionStateByPortIdInContext as matchPortConnectionStateById,
+  matchPortDeviceStateByPortIdInContext as matchPortDeviceStateByPortId,
+} from './internal/mutablePropertyTools/matchMutablePortProperty/matchMutablePortPropertyByPortIdInContext.ts'