effect-web-midi 0.2.3

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

@@ -0,0 +1,95 @@
+/** biome-ignore-all lint/style/useShorthandFunctionType: It's a nice way to
+ * preserve JSDoc comments attached to the function signature */
+import * as Brand from 'effect/Brand';
+import * as Effect from 'effect/Effect';
+import * as EMIDIPort from './EMIDIPort.ts';
+import * as MIDIErrors from './MIDIErrors.ts';
+import * as Util from './Util.ts';
+/**
+ * Thin wrapper around {@linkcode MIDIOutput} instance. Will be seen in all
+ * external code.
+ */
+export interface EMIDIOutput extends EMIDIPort.EMIDIPort<'output'> {
+}
+/**
+ * Asserts an object to be valid EMIDIOutput
+ */
+export declare const assert: (output: unknown) => EMIDIOutput;
+/**
+ *
+ * @internal
+ */
+export declare const make: (rawOutput: MIDIOutput) => EMIDIOutput;
+/**
+ *
+ */
+export declare const is: (output: unknown) => output is EMIDIOutput;
+/**
+ * If `midiMessage` is a System Exclusive message, and the `MIDIAccess` did not
+ * enable System Exclusive access, an `InvalidAccessError` exception will be
+ * thrown
+ *
+ * If the port is `"connected"` and the connection is `"closed"`, asynchronously
+ * tries to open the port. It's unclear in the spec if potential error of `open`
+ * call would result in an `InvalidAccessError` error coming from the `send`
+ * method itself.
+ *
+ * @returns An effect with the same port for easier chaining of operations
+ */
+export declare const send: DualSendMIDIMessageFromPort;
+/**
+ * Clears any enqueued send data that has not yet been sent from the
+ * `MIDIOutput`'s queue. The browser will ensure the MIDI stream is left in a
+ * good state, and if the output port is in the middle of a sysex message, a
+ * sysex termination byte (`0xf7`) will be sent.
+ *
+ * @param polymorphicOutput An effectful output port
+ *
+ * @returns An effect with the same port for easier chaining of operations
+ * @experimental Supported only in Firefox. {@link https://caniuse.com/mdn-api_midioutput_clear|Can I use - MIDIOutput API: clear}
+ * @see {@link https://www.w3.org/TR/webmidi/#dom-midioutput-clear|Web MIDI spec}, {@link https://developer.mozilla.org/en-US/docs/Web/API/MIDIOutput/clear|MDN reference}
+ */
+export declare const clear: <E = never, R = never>(polymorphicOutput: PolymorphicOutput<E, R>) => Effect.Effect<EMIDIPort.EMIDIPort<"output">, E | MIDIErrors.ClearingSendingQueueIsNotSupportedError, R>;
+/**
+ *
+ *
+ */
+export type PolymorphicOutput<E, R> = EMIDIPort.PolymorphicPort<E, R, 'output'>;
+/**
+ *
+ *
+ */
+export type PolymorphicOutputClean = EMIDIPort.PolymorphicPortClean<'output'>;
+export type SendFromPortArgs = [
+    midiMessage: Iterable<number>,
+    timestamp?: DOMHighResTimeStamp
+];
+export interface DualSendMIDIMessageFromPort extends SendMIDIMessagePortLast, SendMIDIMessagePortFirst {
+}
+export interface SendMIDIMessagePortLast {
+    /**
+     *
+     */
+    (...args: SendFromPortArgs): {
+        /**
+         *
+         */
+        <E = never, R = never>(polymorphicOutput: PolymorphicOutput<E, R>): SentMessageEffectFromPort<E, R>;
+    };
+}
+export interface SendMIDIMessagePortFirst {
+    /**
+     *
+     */
+    <E = never, R = never>(polymorphicOutput: PolymorphicOutput<E, R>, ...args: SendFromPortArgs): SentMessageEffectFromPort<E, R>;
+}
+/**
+ *
+ */
+export interface SentMessageEffectFromPort<E = never, R = never> extends Util.SentMessageEffectFrom<EMIDIOutput, E, R> {
+}
+export type Id = EMIDIPort.Id<'output'>;
+export declare const Id: Brand.Brand.Constructor<string & Brand.Brand<"MIDIPortId"> & Brand.Brand<"output">>;
+export interface OutputIdToInstanceMap extends Record<Id, EMIDIOutput> {
+}
+//# sourceMappingURL=EMIDIOutput.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EMIDIOutput.d.ts","sourceRoot":"","sources":["../../../src/internal/EMIDIOutput.ts"],"names":[],"mappings":"AAAA;gEACgE;AAEhE,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAC3C,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAC7C,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAEjC;;;GAGG;AACH,MAAM,WAAW,WAAY,SAAQ,SAAS,CAAC,SAAS,CAAC,QAAQ,CAAC;CAAG;AA+BrE;;GAEG;AACH,eAAO,MAAM,MAAM,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,WAAwB,CAAA;AAQlE;;;GAGG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,SAAS,EAAE,UAAU,KAAK,WAAsB,CAAA;AAQpE;;GAEG;AACH,eAAO,MAAM,EAAE,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,MAAM,IAAI,WAAoB,CAAA;AAWpE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,IAAI,EAAE,2BAmClB,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,KAAK,GAChB,CAAC,UACD,CAAC,gKA0BD,CAAA;AAEF;;;GAGG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,EAAE,CAAC,IAAI,SAAS,CAAC,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAA;AAE/E;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAAG,SAAS,CAAC,oBAAoB,CAAC,QAAQ,CAAC,CAAA;AAE7E,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC;IAC7B,SAAS,CAAC,EAAE,mBAAmB;CAChC,CAAA;AAED,MAAM,WAAW,2BACf,SAAQ,uBAAuB,EAC7B,wBAAwB;CAAG;AAE/B,MAAM,WAAW,uBAAuB;IACtC;;OAEG;IACH,CACE,GAAG,IAAI,EAAE,gBAAgB,GACxB;QACD;;WAEG;QACH,CAAC,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,EACnB,iBAAiB,EAAE,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,GACzC,yBAAyB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;KACnC,CAAA;CACF;AAED,MAAM,WAAW,wBAAwB;IACvC;;OAEG;IACH,CAAC,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,EACnB,iBAAiB,EAAE,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1C,GAAG,IAAI,EAAE,gBAAgB,GACxB,yBAAyB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,yBAAyB,CAAC,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,CAC7D,SAAQ,IAAI,CAAC,qBAAqB,CAAC,WAAW,EAAE,CAAC,EAAE,CAAC,CAAC;CAAG;AAE1D,MAAM,MAAM,EAAE,GAAG,SAAS,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAA;AACvC,eAAO,MAAM,EAAE,qFAAsB,CAAA;AAErC,MAAM,WAAW,qBAAsB,SAAQ,MAAM,CAAC,EAAE,EAAE,WAAW,CAAC;CAAG"}

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

@@ -0,0 +1,90 @@
+/** biome-ignore-all lint/style/useShorthandFunctionType: It's a nice way to
+ * preserve JSDoc comments attached to the function signature */
+import * as Brand from 'effect/Brand';
+import * as Equal from 'effect/Equal';
+import * as Inspectable from 'effect/Inspectable';
+import * as Pipeable from 'effect/Pipeable';
+import type * as EMIDIInput from './EMIDIInput.ts';
+import type * as EMIDIOutput from './EMIDIOutput.ts';
+import type * as Util from './Util.ts';
+/**
+ * Unique symbol used for distinguishing {@linkcode EMIDIPort} instances
+ * from other objects at both runtime and type-level
+ * @internal
+ */
+declare const TypeId: unique symbol;
+/**
+ * Unique symbol used for distinguishing {@linkcode EMIDIPort} instances
+ * from other objects at both runtime and type-level
+ */
+export type TypeId = typeof TypeId;
+/**
+ * Thin wrapper around {@linkcode MIDIPort} instance. Will be seen in all
+ * external code.
+ */
+export interface EMIDIPort<TMIDIPortType extends MIDIPortType = MIDIPortType> extends Equal.Equal, Pipeable.Pipeable, Inspectable.Inspectable, Pick<MIDIPort, 'version' | 'name' | 'manufacturer'> {
+    /**
+     * The **`id`** read-only property of the MIDIPort interface returns the unique ID of the port.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MIDIPort/id)
+     */
+    readonly id: Id<TMIDIPortType>;
+    readonly [TypeId]: TypeId;
+    readonly _tag: 'EMIDIPort';
+    readonly type: TMIDIPortType;
+}
+/**
+ * Thin wrapper around {@linkcode MIDIPort} instance giving access to the
+ * actual field storing it.
+ * @internal
+ */
+export interface EMIDIPortImpl<TPort extends MIDIPort = MIDIPort, TPortType extends MIDIPortType = MIDIPortType> extends EMIDIPort<TPortType> {
+    readonly _port: TPort;
+}
+/**
+ *
+ *
+ * @internal
+ */
+export declare const makeImpl: <TPort extends MIDIPort, TPortType extends MIDIPortType>(port: NoInfer<TPort>, type: TPortType, ClassToAssertInheritance: new (...args: unknown[]) => TPort) => EMIDIPortImpl<TPort, TPortType>;
+/**
+ * Asserts an object to be valid EMIDIPort
+ */
+export declare const assert: (port: unknown) => EMIDIPort;
+/**
+ * @internal
+ */
+export declare const assumeImpl: (port: EMIDIPort) => EMIDIPortImpl;
+/**
+ *
+ *
+ */
+export type PolymorphicPort<E, R, TMIDIPortType extends MIDIPortType = MIDIPortType> = Util.PolymorphicEffect<EMIDIPort<TMIDIPortType>, E, R>;
+/**
+ *
+ *
+ */
+export type PolymorphicPortClean<TMIDIPortType extends MIDIPortType = MIDIPortType> = PolymorphicPort<never, never, TMIDIPortType>;
+export type ExtractTypeFromPort<TPort extends EMIDIPort> = TPort extends EMIDIPort<infer TPortType> ? TPortType : never;
+/**
+ *
+ *
+ * @internal
+ */
+export declare const isImplOfSpecificType: <const TPortType extends MIDIPortType, TPort extends MIDIPort>(type: TPortType, ClassToAssertInheritance: new (...args: unknown[]) => TPort) => (port: unknown) => port is EMIDIPortImpl<TPort, TPortType>;
+/**
+ *
+ *
+ */
+export declare const is: (port: unknown) => port is EMIDIPort;
+/**
+ * Unique identifier of the MIDI port.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MIDIPort/id)
+ */
+export type Id<TPortType extends MIDIPortType> = TPortType extends MIDIPortType ? Brand.Branded<string, 'MIDIPortId'> & Brand.Brand<TPortType> : never;
+export type BothId = Id<MIDIPortType>;
+export declare const BothId: Brand.Brand.Constructor<BothId>;
+export type BothIdToBothInstanceMap = EMIDIInput.InputIdToInstanceMap & EMIDIOutput.OutputIdToInstanceMap;
+export {};
+//# sourceMappingURL=EMIDIPort.d.ts.map

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

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

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

@@ -0,0 +1,270 @@
+import * as Schema from 'effect/Schema';
+import type * as Types from 'effect/Types';
+import * as EMIDIPort from './EMIDIPort.ts';
+declare const AbortError_base: Schema.TaggedErrorClass<AbortError, "AbortError", {
+    readonly _tag: Schema.tag<"AbortError">;
+} & {
+    cause: Schema.Struct<{
+        name: Schema.Literal<["AbortError"]>;
+        message: typeof Schema.NonEmptyTrimmedString;
+        stack: Schema.optionalWith<typeof Schema.NonEmptyTrimmedString, {
+            exact: true;
+        }>;
+        cause: Schema.optionalWith<typeof Schema.Unknown, {
+            exact: true;
+        }>;
+    }>;
+}>;
+/**
+ * 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 declare class AbortError extends AbortError_base {
+    get message(): string;
+}
+declare const UnderlyingSystemError_base: Schema.TaggedErrorClass<UnderlyingSystemError, "UnderlyingSystemError", {
+    readonly _tag: Schema.tag<"UnderlyingSystemError">;
+} & {
+    whileAskingForPermissions: Schema.Struct<{
+        sysex: Schema.optional<typeof Schema.Boolean>;
+        software: Schema.optional<typeof Schema.Boolean>;
+    }>;
+    cause: Schema.Struct<{
+        name: Schema.Literal<["InvalidStateError"]>;
+        message: typeof Schema.NonEmptyTrimmedString;
+        stack: Schema.optionalWith<typeof Schema.NonEmptyTrimmedString, {
+            exact: true;
+        }>;
+        cause: Schema.optionalWith<typeof Schema.Unknown, {
+            exact: true;
+        }>;
+    }>;
+}>;
+/**
+ * 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 declare class UnderlyingSystemError extends UnderlyingSystemError_base {
+    get message(): string;
+}
+declare const MIDIAccessNotSupportedError_base: Schema.TaggedErrorClass<MIDIAccessNotSupportedError, "MIDIAccessNotSupportedError", {
+    readonly _tag: Schema.tag<"MIDIAccessNotSupportedError">;
+} & {
+    whileAskingForPermissions: Schema.Struct<{
+        sysex: Schema.optional<typeof Schema.Boolean>;
+        software: Schema.optional<typeof Schema.Boolean>;
+    }>;
+    cause: Schema.Struct<{
+        name: Schema.Literal<["ReferenceError", "TypeError", "NotSupportedError"]>;
+        message: typeof Schema.NonEmptyTrimmedString;
+        stack: Schema.optionalWith<typeof Schema.NonEmptyTrimmedString, {
+            exact: true;
+        }>;
+        cause: Schema.optionalWith<typeof Schema.Unknown, {
+            exact: true;
+        }>;
+    }>;
+}>;
+/**
+ * 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 declare class MIDIAccessNotSupportedError extends MIDIAccessNotSupportedError_base {
+    get message(): string;
+}
+declare const ClearingSendingQueueIsNotSupportedError_base: Schema.TaggedErrorClass<ClearingSendingQueueIsNotSupportedError, "ClearingSendingQueueIsNotSupportedError", {
+    readonly _tag: Schema.tag<"ClearingSendingQueueIsNotSupportedError">;
+} & {
+    cause: Schema.Struct<{
+        name: Schema.Literal<["TypeError", "NotSupportedError"]>;
+        message: typeof Schema.NonEmptyTrimmedString;
+        stack: Schema.optionalWith<typeof Schema.NonEmptyTrimmedString, {
+            exact: true;
+        }>;
+        cause: Schema.optionalWith<typeof Schema.Unknown, {
+            exact: true;
+        }>;
+    }>;
+    portId: Schema.BrandSchema<string & EMIDIPort.BothId, string, never>;
+}>;
+/**
+ * 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 declare class ClearingSendingQueueIsNotSupportedError extends ClearingSendingQueueIsNotSupportedError_base {
+    get message(): string;
+}
+declare const CannotOpenUnavailablePortError_base: Schema.TaggedErrorClass<CannotOpenUnavailablePortError, "CannotOpenUnavailablePortError", {
+    readonly _tag: Schema.tag<"CannotOpenUnavailablePortError">;
+} & {
+    cause: Schema.Struct<{
+        name: Schema.Literal<["InvalidAccessError", "NotAllowedError", "InvalidStateError"]>;
+        message: typeof Schema.NonEmptyTrimmedString;
+        stack: Schema.optionalWith<typeof Schema.NonEmptyTrimmedString, {
+            exact: true;
+        }>;
+        cause: Schema.optionalWith<typeof Schema.Unknown, {
+            exact: true;
+        }>;
+    }>;
+    portId: Schema.BrandSchema<string & EMIDIPort.BothId, string, never>;
+}>;
+/**
+ * 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 declare class CannotOpenUnavailablePortError extends CannotOpenUnavailablePortError_base {
+    get message(): string;
+}
+declare const CannotSendToDisconnectedPortError_base: Schema.TaggedErrorClass<CannotSendToDisconnectedPortError, "CannotSendToDisconnectedPortError", {
+    readonly _tag: Schema.tag<"CannotSendToDisconnectedPortError">;
+} & {
+    cause: Schema.Struct<{
+        name: Schema.Literal<["InvalidStateError"]>;
+        message: typeof Schema.NonEmptyTrimmedString;
+        stack: Schema.optionalWith<typeof Schema.NonEmptyTrimmedString, {
+            exact: true;
+        }>;
+        cause: Schema.optionalWith<typeof Schema.Unknown, {
+            exact: true;
+        }>;
+    }>;
+    portId: Schema.BrandSchema<string & EMIDIPort.BothId, string, never>;
+}>;
+/**
+ * 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 declare class CannotSendToDisconnectedPortError extends CannotSendToDisconnectedPortError_base {
+    get message(): string;
+}
+declare const CannotSendSysexMessageError_base: Schema.TaggedErrorClass<CannotSendSysexMessageError, "CannotSendSysexMessageError", {
+    readonly _tag: Schema.tag<"CannotSendSysexMessageError">;
+} & {
+    cause: Schema.Struct<{
+        name: Schema.Literal<["InvalidAccessError", "NotAllowedError"]>;
+        message: typeof Schema.NonEmptyTrimmedString;
+        stack: Schema.optionalWith<typeof Schema.NonEmptyTrimmedString, {
+            exact: true;
+        }>;
+        cause: Schema.optionalWith<typeof Schema.Unknown, {
+            exact: true;
+        }>;
+    }>;
+    portId: Schema.BrandSchema<string & EMIDIPort.BothId, string, never>;
+}>;
+/**
+ * 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 declare class CannotSendSysexMessageError extends CannotSendSysexMessageError_base {
+    get message(): string;
+}
+declare const MIDIAccessNotAllowedError_base: Schema.TaggedErrorClass<MIDIAccessNotAllowedError, "MIDIAccessNotAllowedError", {
+    readonly _tag: Schema.tag<"MIDIAccessNotAllowedError">;
+} & {
+    whileAskingForPermissions: Schema.Struct<{
+        sysex: Schema.optional<typeof Schema.Boolean>;
+        software: Schema.optional<typeof Schema.Boolean>;
+    }>;
+    cause: Schema.Struct<{
+        name: Schema.Literal<["NotAllowedError", "SecurityError"]>;
+        message: typeof Schema.NonEmptyTrimmedString;
+        stack: Schema.optionalWith<typeof Schema.NonEmptyTrimmedString, {
+            exact: true;
+        }>;
+        cause: Schema.optionalWith<typeof Schema.Unknown, {
+            exact: true;
+        }>;
+    }>;
+}>;
+/**
+ * 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 declare class MIDIAccessNotAllowedError extends MIDIAccessNotAllowedError_base {
+    get message(): string;
+}
+declare const MalformedMIDIMessageError_base: Schema.TaggedErrorClass<MalformedMIDIMessageError, "MalformedMIDIMessageError", {
+    readonly _tag: Schema.tag<"MalformedMIDIMessageError">;
+} & {
+    cause: Schema.Struct<{
+        name: Schema.Literal<["TypeError"]>;
+        message: typeof Schema.NonEmptyTrimmedString;
+        stack: Schema.optionalWith<typeof Schema.NonEmptyTrimmedString, {
+            exact: true;
+        }>;
+        cause: Schema.optionalWith<typeof Schema.Unknown, {
+            exact: true;
+        }>;
+    }>;
+    portId: Schema.BrandSchema<string & EMIDIPort.BothId, string, never>;
+    midiMessage: Schema.Array$<typeof Schema.Int>;
+}>;
+/**
+ * Thrown when data to be sent is not a valid sequence or does not contain a
+ * valid MIDI message
+ *
+ * Wraps `TypeError`
+ */
+export declare class MalformedMIDIMessageError extends MalformedMIDIMessageError_base {
+    get message(): string;
+}
+declare const PortNotFoundError_base: Schema.TaggedErrorClass<PortNotFoundError, "PortNotFound", {
+    readonly _tag: Schema.tag<"PortNotFound">;
+} & {
+    portId: Schema.BrandSchema<string & EMIDIPort.BothId, string, never>;
+}>;
+/**
+ * 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 declare class PortNotFoundError extends PortNotFoundError_base {
+    get message(): string;
+}
+/**
+ *
+ * @internal
+ */
+export declare 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) => InstanceType<TErrorClassUnion>;
+export {};
+//# sourceMappingURL=MIDIErrors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MIDIErrors.d.ts","sourceRoot":"","sources":["../../../src/internal/MIDIErrors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAG1C,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;;;;;;;;;;;;;;;AA6B3C;;;;;;GAMG;AACH,qBAAa,UAAW,SAAQ,eAE9B;IACA,IAAa,OAAO,WAEnB;CACF;;;;;;;;;;;;;;;;;;;AAED;;;;;;;GAOG;AACH,qBAAa,qBAAsB,SAAQ,0BAM1C;IACC,IAAa,OAAO,WAEnB;CACF;;;;;;;;;;;;;;;;;;;AAED;;;;;;;GAOG;AACH,qBAAa,2BAA4B,SAAQ,gCAQhD;IACC,IAAa,OAAO,WAEnB;CACF;;;;;;;;;;;;;;;;AAED;;;;;;;GAOG;AACH,qBAAa,uCAAwC,SAAQ,4CAM5D;IACC,IAAa,OAAO,WAEnB;CACF;;;;;;;;;;;;;;;;AAED;;;;;;;;GAQG;AACH,qBAAa,8BAA+B,SAAQ,mCAYnD;IACC,IAAa,OAAO,WAEnB;CACF;;;;;;;;;;;;;;;;AAED;;;;;;GAMG;AACH,qBAAa,iCAAkC,SAAQ,sCAMtD;IACC,IAAa,OAAO,WAEnB;CACF;;;;;;;;;;;;;;;;AAED;;;;;;;GAOG;AACH,qBAAa,2BAA4B,SAAQ,gCAMhD;IACC,IAAa,OAAO,WAEnB;CACF;;;;;;;;;;;;;;;;;;;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,yBAA0B,SAAQ,8BAM9C;IACC,IAAa,OAAO,WAEnB;CACF;;;;;;;;;;;;;;;;;AAED;;;;;GAKG;AACH,qBAAa,yBAA0B,SAAQ,8BAO9C;IACC,IAAa,OAAO,WAEnB;CACF;;;;;;AAED;;;;;GAKG;AACH,qBAAa,iBAAkB,SAAQ,sBAGtC;IACC,IAAa,OAAO,WAEnB;CACF;AAGD;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAC1B,gBAAgB,SAAS,KAAK,GAAG,EAAE,GAAG,KAAK,KAAK,OAC1C;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,CAAA;CAAE,iBAC1B,MAAM,QACf,IAAI,CACR,KAAK,CAAC,mBAAmB,CACvB,gBAAgB,SAAS,KAAK,GAAG,EAAE,MAAM,CAAC,KAAK,GAAG,GAAG,CAAC,GAAG,KAAK,CAC/D,EACD,OAAO,CACR,aAEK,OAAO,KAQP,YAAY,CAAC,gBAAgB,CACpC,CAAA"}

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

@@ -0,0 +1,74 @@
+import * as Stream from 'effect/Stream';
+import * as EMIDIAccess from './EMIDIAccess.ts';
+import * as EMIDIInput from './EMIDIInput.ts';
+import type * as MIDIErrors from './MIDIErrors.ts';
+import * as Parsing from './Parsing.ts';
+import type * as StreamMaker from './StreamMaker.ts';
+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 declare const makeNoteReleaseStreamByInput: DualMakeSpecificMessageStreamFromInput<Parsing.NoteReleasePayload>;
+export declare const makeNoteReleaseStreamByInputIdAndAccess: DualMakeSpecificMessageStreamFromAccess<Parsing.NoteReleasePayload>;
+export declare const makeNoteReleaseStreamByInputIdInContext: <const TForbidNullsStrategy extends ForbidNullsStrategy = undefined>(id: EMIDIInput.Id, options?: StreamMaker.StreamMakerOptions<TForbidNullsStrategy>) => MakeSpecificMessageStreamResult<Parsing.NoteReleasePayload, TForbidNullsStrategy, MIDIErrors.PortNotFoundError, EMIDIAccess.EMIDIAccess>;
+export declare const makeNotePressStreamByInput: DualMakeSpecificMessageStreamFromInput<Parsing.NotePressPayload>;
+export declare const makeNotePressStreamByInputIdAndAccess: DualMakeSpecificMessageStreamFromAccess<Parsing.NotePressPayload>;
+export declare const makeNotePressStreamByInputIdInContext: <const TForbidNullsStrategy extends ForbidNullsStrategy = undefined>(id: EMIDIInput.Id, options?: StreamMaker.StreamMakerOptions<TForbidNullsStrategy>) => MakeSpecificMessageStreamResult<Parsing.NotePressPayload, TForbidNullsStrategy, MIDIErrors.PortNotFoundError, EMIDIAccess.EMIDIAccess>;
+export declare const makeUnknownReplyStreamByInput: DualMakeSpecificMessageStreamFromInput<Parsing.UnknownReplyPayload>;
+export declare const makeUnknownReplyStreamByInputIdAndAccess: DualMakeSpecificMessageStreamFromAccess<Parsing.UnknownReplyPayload>;
+export declare const makeUnknownReplyStreamByInputIdInContext: <const TForbidNullsStrategy extends ForbidNullsStrategy = undefined>(id: EMIDIInput.Id, options?: StreamMaker.StreamMakerOptions<TForbidNullsStrategy>) => MakeSpecificMessageStreamResult<Parsing.UnknownReplyPayload, TForbidNullsStrategy, MIDIErrors.PortNotFoundError, EMIDIAccess.EMIDIAccess>;
+export declare const makeControlChangeStreamByInput: DualMakeSpecificMessageStreamFromInput<Parsing.ControlChangePayload>;
+export declare const makeControlChangeStreamByInputIdAndAccess: DualMakeSpecificMessageStreamFromAccess<Parsing.ControlChangePayload>;
+export declare const makeControlChangeStreamByInputIdInContext: <const TForbidNullsStrategy extends ForbidNullsStrategy = undefined>(id: EMIDIInput.Id, options?: StreamMaker.StreamMakerOptions<TForbidNullsStrategy>) => MakeSpecificMessageStreamResult<Parsing.ControlChangePayload, TForbidNullsStrategy, MIDIErrors.PortNotFoundError, EMIDIAccess.EMIDIAccess>;
+export declare const makeChannelPressureStreamByInput: DualMakeSpecificMessageStreamFromInput<Parsing.ChannelPressurePayload>;
+export declare const makeChannelPressureStreamByInputIdAndAccess: DualMakeSpecificMessageStreamFromAccess<Parsing.ChannelPressurePayload>;
+export declare const makeChannelPressureStreamByInputIdInContext: <const TForbidNullsStrategy extends ForbidNullsStrategy = undefined>(id: EMIDIInput.Id, options?: StreamMaker.StreamMakerOptions<TForbidNullsStrategy>) => MakeSpecificMessageStreamResult<Parsing.ChannelPressurePayload, TForbidNullsStrategy, MIDIErrors.PortNotFoundError, EMIDIAccess.EMIDIAccess>;
+export declare const makeTouchpadReleaseStreamByInput: DualMakeSpecificMessageStreamFromInput<Parsing.TouchpadReleasePayload>;
+export declare const makeTouchpadReleaseStreamByInputIdAndAccess: DualMakeSpecificMessageStreamFromAccess<Parsing.TouchpadReleasePayload>;
+export declare const makeTouchpadReleaseStreamByInputIdInContext: <const TForbidNullsStrategy extends ForbidNullsStrategy = undefined>(id: EMIDIInput.Id, options?: StreamMaker.StreamMakerOptions<TForbidNullsStrategy>) => MakeSpecificMessageStreamResult<Parsing.TouchpadReleasePayload, TForbidNullsStrategy, MIDIErrors.PortNotFoundError, EMIDIAccess.EMIDIAccess>;
+export declare const makePitchBendChangeStreamByInput: DualMakeSpecificMessageStreamFromInput<Parsing.PitchBendChangePayload>;
+export declare const makePitchBendChangeStreamByInputIdAndAccess: DualMakeSpecificMessageStreamFromAccess<Parsing.PitchBendChangePayload>;
+export declare const makePitchBendChangeStreamByInputIdInContext: <const TForbidNullsStrategy extends ForbidNullsStrategy = undefined>(id: EMIDIInput.Id, options?: StreamMaker.StreamMakerOptions<TForbidNullsStrategy>) => MakeSpecificMessageStreamResult<Parsing.PitchBendChangePayload, TForbidNullsStrategy, MIDIErrors.PortNotFoundError, EMIDIAccess.EMIDIAccess>;
+export declare const makeTouchpadPositionUpdateStreamByInput: DualMakeSpecificMessageStreamFromInput<Parsing.TouchpadPositionUpdatePayload>;
+export declare const makeTouchpadPositionUpdateStreamByInputIdAndAccess: DualMakeSpecificMessageStreamFromAccess<Parsing.TouchpadPositionUpdatePayload>;
+export declare const makeTouchpadPositionUpdateStreamByInputIdInContext: <const TForbidNullsStrategy extends ForbidNullsStrategy = undefined>(id: EMIDIInput.Id, options?: StreamMaker.StreamMakerOptions<TForbidNullsStrategy>) => MakeSpecificMessageStreamResult<Parsing.TouchpadPositionUpdatePayload, TForbidNullsStrategy, MIDIErrors.PortNotFoundError, EMIDIAccess.EMIDIAccess>;
+//# sourceMappingURL=MIDIEventStreams.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MIDIEventStreams.d.ts","sourceRoot":"","sources":["../../../src/internal/MIDIEventStreams.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAC/C,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAE7C,OAAO,KAAK,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAClD,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC,OAAO,KAAK,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAiDpD,MAAM,MAAM,mBAAmB,GAAG,OAAO,CACvC,WAAW,CAAC,cAAc,EAC1B,aAAa,CACd,CAAA;AAED,MAAM,WAAW,sCAAsC,CACrD,OAAO,SAAS,OAAO,CAAC,YAAY,CACpC,SAAQ,kCAAkC,CAAC,OAAO,CAAC,EACjD,mCAAmC,CAAC,OAAO,CAAC;CAAG;AAEnD,MAAM,WAAW,mCAAmC,CAClD,OAAO,SAAS,OAAO,CAAC,YAAY;IAEpC;;OAEG;IACH,CACE,CAAC,GAAG,KAAK,EACT,CAAC,GAAG,KAAK,EACT,KAAK,CAAC,oBAAoB,SAAS,mBAAmB,GAAG,SAAS,EAElE,gBAAgB,EAAE,UAAU,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,EACnD,OAAO,CAAC,EAAE,WAAW,CAAC,kBAAkB,CAAC,oBAAoB,CAAC,GAC7D,+BAA+B,CAAC,OAAO,EAAE,oBAAoB,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;CACxE;AAED,MAAM,WAAW,kCAAkC,CACjD,OAAO,SAAS,OAAO,CAAC,YAAY;IAEpC;;OAEG;IACH,CAAC,KAAK,CAAC,oBAAoB,SAAS,mBAAmB,GAAG,SAAS,EACjE,OAAO,CAAC,EAAE,WAAW,CAAC,kBAAkB,CAAC,oBAAoB,CAAC,GAC7D,4CAA4C,CAAC,OAAO,EAAE,oBAAoB,CAAC,CAAA;CAC/E;AAED,MAAM,WAAW,4CAA4C,CAC3D,OAAO,SAAS,OAAO,CAAC,YAAY,EACpC,oBAAoB,SAAS,mBAAmB;IAEhD;;OAEG;IACH,CAAC,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,EACnB,gBAAgB,EAAE,UAAU,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,GAClD,+BAA+B,CAAC,OAAO,EAAE,oBAAoB,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;CACxE;AAMD,MAAM,WAAW,uCAAuC,CACtD,OAAO,SAAS,OAAO,CAAC,YAAY,CACpC,SAAQ,mCAAmC,CAAC,OAAO,CAAC,EAClD,oCAAoC,CAAC,OAAO,CAAC;CAAG;AAEpD,MAAM,WAAW,oCAAoC,CACnD,OAAO,SAAS,OAAO,CAAC,YAAY;IAEpC;;OAEG;IACH,CACE,CAAC,GAAG,KAAK,EACT,CAAC,GAAG,KAAK,EACT,KAAK,CAAC,oBAAoB,SAAS,mBAAmB,GAAG,SAAS,EAElE,iBAAiB,EAAE,WAAW,CAAC,yBAAyB,CAAC,CAAC,EAAE,CAAC,CAAC,EAC9D,EAAE,EAAE,UAAU,CAAC,EAAE,EACjB,OAAO,CAAC,EAAE,WAAW,CAAC,kBAAkB,CAAC,oBAAoB,CAAC,GAC7D,+BAA+B,CAChC,OAAO,EACP,oBAAoB,EACpB,CAAC,GAAG,UAAU,CAAC,iBAAiB,EAChC,CAAC,CACF,CAAA;CACF;AAED,MAAM,WAAW,mCAAmC,CAClD,OAAO,SAAS,OAAO,CAAC,YAAY;IAEpC;;OAEG;IACH,CAAC,KAAK,CAAC,oBAAoB,SAAS,mBAAmB,GAAG,SAAS,EACjE,EAAE,EAAE,UAAU,CAAC,EAAE,EACjB,OAAO,CAAC,EAAE,WAAW,CAAC,kBAAkB,CAAC,oBAAoB,CAAC,GAC7D,6CAA6C,CAC9C,OAAO,EACP,oBAAoB,CACrB,CAAA;CACF;AAED,MAAM,WAAW,6CAA6C,CAC5D,OAAO,SAAS,OAAO,CAAC,YAAY,EACpC,oBAAoB,SAAS,mBAAmB;IAEhD;;OAEG;IACH,CAAC,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,EACnB,iBAAiB,EAAE,WAAW,CAAC,yBAAyB,CAAC,CAAC,EAAE,CAAC,CAAC,GAC7D,+BAA+B,CAChC,OAAO,EACP,oBAAoB,EACpB,CAAC,GAAG,UAAU,CAAC,iBAAiB,EAChC,CAAC,CACF,CAAA;CACF;AAED,MAAM,WAAW,+BAA+B,CAC9C,OAAO,SAAS,OAAO,CAAC,YAAY,EACpC,oBAAoB,SAAS,mBAAmB,EAChD,CAAC,EACD,CAAC,CACD,SAAQ,MAAM,CAAC,MAAM,CACnB,OAAO,CAAC,iBAAiB,CAAC,OAAO,CAAC,EAClC,WAAW,CAAC,WAAW,CAAC,oBAAoB,EAAE,CAAC,CAAC,EAChD,CAAC,CACF;CAAG;AAEN,eAAO,MAAM,4BAA4B,oEACsB,CAAA;AAE/D,eAAO,MAAM,uCAAuC,qEACoB,CAAA;AAExE,eAAO,MAAM,uCAAuC,SArJpC,oBAAoB,SAAS,mBAAmB,kBACxD,UAAU,CAAC,EAAE,6MAqJsD,CAAA;AAE3E,eAAO,MAAM,0BAA0B,kEACsB,CAAA;AAE7D,eAAO,MAAM,qCAAqC,mEACoB,CAAA;AAEtE,eAAO,MAAM,qCAAqC,SA9JlC,oBAAoB,SAAS,mBAAmB,kBACxD,UAAU,CAAC,EAAE,2MA8JoD,CAAA;AAEzE,eAAO,MAAM,6BAA6B,qEACsB,CAAA;AAEhE,eAAO,MAAM,wCAAwC,sEACoB,CAAA;AAEzE,eAAO,MAAM,wCAAwC,SAvKrC,oBAAoB,SAAS,mBAAmB,kBACxD,UAAU,CAAC,EAAE,8MAuKuD,CAAA;AAE5E,eAAO,MAAM,8BAA8B,sEACsB,CAAA;AAEjE,eAAO,MAAM,yCAAyC,uEACoB,CAAA;AAE1E,eAAO,MAAM,yCAAyC,SAhLtC,oBAAoB,SAAS,mBAAmB,kBACxD,UAAU,CAAC,EAAE,+MAgLwD,CAAA;AAE7E,eAAO,MAAM,gCAAgC,wEACsB,CAAA;AAEnE,eAAO,MAAM,2CAA2C,yEACoB,CAAA;AAE5E,eAAO,MAAM,2CAA2C,SAzLxC,oBAAoB,SAAS,mBAAmB,kBACxD,UAAU,CAAC,EAAE,iNAyL0D,CAAA;AAE/E,eAAO,MAAM,gCAAgC,wEACsB,CAAA;AAEnE,eAAO,MAAM,2CAA2C,yEACoB,CAAA;AAE5E,eAAO,MAAM,2CAA2C,SAlMxC,oBAAoB,SAAS,mBAAmB,kBACxD,UAAU,CAAC,EAAE,iNAkM0D,CAAA;AAE/E,eAAO,MAAM,gCAAgC,wEACsB,CAAA;AAEnE,eAAO,MAAM,2CAA2C,yEACoB,CAAA;AAE5E,eAAO,MAAM,2CAA2C,SA3MxC,oBAAoB,SAAS,mBAAmB,kBACxD,UAAU,CAAC,EAAE,iNA2M0D,CAAA;AAE/E,eAAO,MAAM,uCAAuC,+EACsB,CAAA;AAE1E,eAAO,MAAM,kDAAkD,gFAG5D,CAAA;AAEH,eAAO,MAAM,kDAAkD,SAtN/C,oBAAoB,SAAS,mBAAmB,kBACxD,UAAU,CAAC,EAAE,wNAwNlB,CAAA"}

package/dist-types/src/internal/MIDIPortMethodCalls/acquireReleasePortConnection/acquireReleasePortConnectionByPort.d.ts

@@ -0,0 +1,16 @@
+import type * as Scope from 'effect/Scope';
+import type * as MIDIErrors from '../../MIDIErrors.ts';
+import type { TouchPort } from '../makeMIDIPortMethodCallerFactory.ts';
+/**
+ *
+ */
+export declare const acquireReleasePortConnectionByPort: TouchPort<MIDIErrors.CannotOpenUnavailablePortError, Scope.Scope, MIDIPortType>;
+/**
+ *
+ */
+export declare const acquireReleaseInputConnectionByPort: TouchPort<MIDIErrors.CannotOpenUnavailablePortError, Scope.Scope, "input">;
+/**
+ *
+ */
+export declare const acquireReleaseOutputConnectionByPort: TouchPort<MIDIErrors.CannotOpenUnavailablePortError, Scope.Scope, "output">;
+//# sourceMappingURL=acquireReleasePortConnectionByPort.d.ts.map

package/dist-types/src/internal/MIDIPortMethodCalls/acquireReleasePortConnection/acquireReleasePortConnectionByPort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acquireReleasePortConnectionByPort.d.ts","sourceRoot":"","sources":["../../../../../src/internal/MIDIPortMethodCalls/acquireReleasePortConnection/acquireReleasePortConnectionByPort.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAK1C,OAAO,KAAK,KAAK,UAAU,MAAM,qBAAqB,CAAA;AAEtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uCAAuC,CAAA;AAuBtE;;GAEG;AACH,eAAO,MAAM,kCAAkC,iFACD,CAAA;AAE9C;;GAEG;AACH,eAAO,MAAM,mCAAmC,4EACD,CAAA;AAE/C;;GAEG;AACH,eAAO,MAAM,oCAAoC,6EACD,CAAA"}

package/dist-types/src/internal/MIDIPortMethodCalls/acquireReleasePortConnection/acquireReleasePortConnectionByPortIdAndAccess.d.ts

@@ -0,0 +1,15 @@
+/** biome-ignore-all lint/style/useShorthandFunctionType: It's a nice way to
+ * preserve JSDoc comments attached to the function signature */
+/**
+ *
+ */
+export declare const acquireReleasePortConnectionByPortIdAndAccess: import("../../EMIDIAccess.ts").GetThingByPortId<import("../../EMIDIAccess.ts").EMIDIAccessInstance, "input" | "output", never, never, import("../../MIDIErrors.ts").CannotOpenUnavailablePortError | import("../../MIDIErrors.ts").PortNotFoundError, import("effect/Scope").Scope>;
+/**
+ *
+ */
+export declare const acquireReleaseInputConnectionByPortIdAndAccess: import("../../EMIDIAccess.ts").GetThingByPortId<import("../../EMIDIAccess.ts").EMIDIAccessInstance, "input", never, never, import("../../MIDIErrors.ts").CannotOpenUnavailablePortError | import("../../MIDIErrors.ts").PortNotFoundError, import("effect/Scope").Scope>;
+/**
+ *
+ */
+export declare const acquireReleaseOutputConnectionByPortIdAndAccess: import("../../EMIDIAccess.ts").GetThingByPortId<import("../../EMIDIAccess.ts").EMIDIAccessInstance, "output", never, never, import("../../MIDIErrors.ts").CannotOpenUnavailablePortError | import("../../MIDIErrors.ts").PortNotFoundError, import("effect/Scope").Scope>;
+//# sourceMappingURL=acquireReleasePortConnectionByPortIdAndAccess.d.ts.map

package/dist-types/src/internal/MIDIPortMethodCalls/acquireReleasePortConnection/acquireReleasePortConnectionByPortIdAndAccess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acquireReleasePortConnectionByPortIdAndAccess.d.ts","sourceRoot":"","sources":["../../../../../src/internal/MIDIPortMethodCalls/acquireReleasePortConnection/acquireReleasePortConnectionByPortIdAndAccess.ts"],"names":[],"mappings":"AACA;gEACgE;AAMhE;;GAEG;AACH,eAAO,MAAM,6CAA6C,qRAGzD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,8CAA8C,0QAG1D,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,+CAA+C,2QAG3D,CAAA"}

package/dist-types/src/internal/MIDIPortMethodCalls/acquireReleasePortConnection/acquireReleasePortConnectionByPortIdInContext.d.ts

@@ -0,0 +1,13 @@
+/**
+ *
+ */
+export declare const acquireReleasePortConnectionByPortIdInContext: (id: import("../../EMIDIPort.ts").BothId) => import("effect/Effect").Effect<import("../../EMIDIPort.ts").EMIDIPort<"input" | "output">, import("../../MIDIErrors.ts").CannotOpenUnavailablePortError | import("../../MIDIErrors.ts").PortNotFoundError, import("../../EMIDIAccess.ts").EMIDIAccess | import("effect/Scope").Scope>;
+/**
+ *
+ */
+export declare const acquireReleaseInputConnectionByPortIdInContext: (id: string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"input">) => import("effect/Effect").Effect<import("../../EMIDIPort.ts").EMIDIPort<"input">, import("../../MIDIErrors.ts").CannotOpenUnavailablePortError | import("../../MIDIErrors.ts").PortNotFoundError, import("../../EMIDIAccess.ts").EMIDIAccess | import("effect/Scope").Scope>;
+/**
+ *
+ */
+export declare const acquireReleaseOutputConnectionByPortIdInContext: (id: string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"output">) => import("effect/Effect").Effect<import("../../EMIDIPort.ts").EMIDIPort<"output">, import("../../MIDIErrors.ts").CannotOpenUnavailablePortError | import("../../MIDIErrors.ts").PortNotFoundError, import("../../EMIDIAccess.ts").EMIDIAccess | import("effect/Scope").Scope>;
+//# sourceMappingURL=acquireReleasePortConnectionByPortIdInContext.d.ts.map

package/dist-types/src/internal/MIDIPortMethodCalls/acquireReleasePortConnection/acquireReleasePortConnectionByPortIdInContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acquireReleasePortConnectionByPortIdInContext.d.ts","sourceRoot":"","sources":["../../../../../src/internal/MIDIPortMethodCalls/acquireReleasePortConnection/acquireReleasePortConnectionByPortIdInContext.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,eAAO,MAAM,6CAA6C,oUAGzD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,8CAA8C,iXAG1D,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,+CAA+C,mXAG3D,CAAA"}

package/dist-types/src/internal/MIDIPortMethodCalls/actOnPort.d.ts

@@ -0,0 +1,11 @@
+/** biome-ignore-all lint/style/useShorthandFunctionType: It's a nice way to
+ * preserve JSDoc comments attached to the function signature */
+import * as EMIDIAccess from '../EMIDIAccess.ts';
+import type * as Get from '../getPortByPortId/getPortByPortIdAndAccess.ts';
+import type * as Make from './makeMIDIPortMethodCallerFactory.ts';
+/**
+ *
+ * @internal
+ */
+export declare 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>;
+//# sourceMappingURL=actOnPort.d.ts.map

package/dist-types/src/internal/MIDIPortMethodCalls/actOnPort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actOnPort.d.ts","sourceRoot":"","sources":["../../../../src/internal/MIDIPortMethodCalls/actOnPort.ts"],"names":[],"mappings":"AAAA;gEACgE;AAKhE,OAAO,KAAK,WAAW,MAAM,mBAAmB,CAAA;AAEhD,OAAO,KAAK,KAAK,GAAG,MAAM,gDAAgD,CAAA;AAC1E,OAAO,KAAK,KAAK,IAAI,MAAM,sCAAsC,CAAA;AAEjE;;;GAGG;AACH,eAAO,MAAM,SAAS,GACpB,aAAa,SAAS,YAAY,EAClC,2BAA2B,SAAS,0BAA0B,GAC5D,aAAa,EACf,0BAA0B,SAAS,YAAY,EAC/C,iBAAiB,GAAG,KAAK,EACzB,uBAAuB,GAAG,KAAK,EAC/B,gBAAgB,GAAG,KAAK,EACxB,sBAAsB,GAAG,KAAK,8BAEF,GAAG,CAAC,WAAW,CACzC,2BAA2B,EAC3B,aAAa,EACb,KAAK,EACL,KAAK,EACL,iBAAiB,EACjB,uBAAuB,CACxB,OACI,IAAI,CAAC,SAAS,CACjB,gBAAgB,EAChB,sBAAsB,EACtB,0BAA0B,CAC3B,KACA,WAAW,CAAC,gBAAgB,CAC7B,WAAW,CAAC,mBAAmB,EAC/B,2BAA2B,EAC3B,KAAK,EACL,KAAK,EACL,iBAAiB,GAAG,gBAAgB,EACpC,uBAAuB,GAAG,sBAAsB,CAqB/C,CAAA"}