effect-web-midi 0.2.3

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

@@ -0,0 +1,551 @@
+/** biome-ignore-all lint/style/useShorthandFunctionType: It's a nice way to
+ * preserve JSDoc comments attached to the function signature */
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Equal from 'effect/Equal';
+import * as Inspectable from 'effect/Inspectable';
+import * as Layer from 'effect/Layer';
+import * as Pipeable from 'effect/Pipeable';
+import type * as Types from 'effect/Types';
+import * as EMIDIInput from './EMIDIInput.ts';
+import * as EMIDIOutput from './EMIDIOutput.ts';
+import type * as EMIDIPort from './EMIDIPort.ts';
+import * as MIDIErrors from './MIDIErrors.ts';
+import * as StreamMaker from './StreamMaker.ts';
+import * as Util from './Util.ts';
+/**
+ * Unique symbol used for distinguishing
+ * {@linkcode EMIDIAccessInstance|EMIDIAccess.Instance}s from other objects at
+ * both runtime and type-level
+ * @internal
+ */
+declare const TypeId: unique symbol;
+/**
+ * Unique symbol used for distinguishing
+ * {@linkcode EMIDIAccessInstance|EMIDIAccess.Instance}s from other objects at
+ * both runtime and type-level
+ */
+export type TypeId = typeof TypeId;
+declare const EMIDIAccess_base: Context.TagClass<EMIDIAccess, "effect-web-midi/EMIDIAccess", EMIDIAccessInstance>;
+/**
+ * A tag that allows to provide
+ * {@linkcode EMIDIAccessInstance|EMIDIAccess.Instance} once with e.g.
+ * {@linkcode layer}, {@linkcode layerSystemExclusiveSupported}, etc. and reuse
+ * it anywhere, instead of repeatedly {@linkcode request}ing it.
+ *
+ * The downside of using DI might be that in different places of the app it
+ * would be harder to maintain tight MIDI permission scopes.
+ *
+ * @example
+ * ```ts
+ * import * as EMIDIAccess from 'effect-web-midi/EMIDIAccess';
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   //  ^ Effect.Effect<
+ *   //      void,
+ *   //      | AbortError
+ *   //      | UnderlyingSystemError
+ *   //      | MIDIAccessNotAllowedError
+ *   //      | MIDIAccessNotSupportedError
+ *   //      never
+ *   //    >
+ *
+ *   const access = yield* EMIDIAccess.EMIDIAccess
+ *   //    ^ EMIDIAccess.Instance
+ *
+ *   console.log(access.sysexEnabled)
+ *   //                 ^ true
+ * }).pipe(Effect.provide(EMIDIAccess.layerSystemExclusiveSupported))
+ * ```
+ *
+ * @see `navigator.requestMIDIAccess` {@link https://www.w3.org/TR/webmidi/#dom-navigator-requestmidiaccess|Web MIDI spec}, {@link https://developer.mozilla.org/en-US/docs/Web/API/Navigator/requestMIDIAccess|MDN reference}
+ */
+export declare class EMIDIAccess extends EMIDIAccess_base {
+}
+export interface RequestMIDIAccessOptions {
+    /**
+     * This field informs the system whether the ability to send and receive
+     * `System Exclusive` messages is requested or allowed on a given
+     * {@linkcode EMIDIAccessInstance|EMIDIAccess.Instance} object.
+     *
+     * If this field is set to `true`, but `System Exclusive` support is denied
+     * (either by policy or by user action), the access request will fail with a
+     * {@linkcode MIDIErrors.MIDIAccessNotAllowedError} error.
+     *
+     * If this support is not requested (and allowed), the system will throw
+     * exceptions if the user tries to send `System Exclusive` messages, and will
+     * silently mask out any `System Exclusive` messages received on the port.
+     *
+     * @default false
+     * @see {@link https://www.w3.org/TR/webmidi/#dom-midioptions-sysex|Web MIDI spec}, {@link https://developer.mozilla.org/en-US/docs/Web/API/Navigator/requestMIDIAccess#sysex|MDN reference}
+     */
+    readonly sysex?: boolean;
+    /**
+     * This field informs the system whether the ability to utilize any software
+     * synthesizers installed in the host system is requested or allowed on a
+     * given {@linkcode EMIDIAccessInstance|EMIDIAccess.Instance} object.
+     *
+     * If this field is set to `true`, but software synthesizer support is denied
+     * (either by policy or by user action), the access request will fail with a
+     * {@linkcode MIDIErrors.MIDIAccessNotAllowedError} error.
+     *
+     * If this support is not requested,
+     * {@linkcode AllPortsRecord|EMIDIAccess.AllPortsRecord},
+     * {@linkcode getInputsRecord|EMIDIAccess.getInputsRecord},
+     * {@linkcode OutputsArray|EMIDIAccess.OutputsArray}, etc. would not include
+     * any software synthesizers.
+     *
+     * Note that may result in a two-step request procedure if software
+     * synthesizer support is desired but not required - software synthesizers may
+     * be disabled when MIDI hardware device access is allowed.
+     *
+     * @default false
+     * @see {@link https://www.w3.org/TR/webmidi/#dom-midioptions-software|Web MIDI spec}, {@link https://developer.mozilla.org/en-US/docs/Web/API/Navigator/requestMIDIAccess#software|MDN reference}
+     */
+    readonly software?: boolean;
+}
+/**
+ * Thin wrapper around raw {@linkcode MIDIAccess} instance. Will be seen in all the
+ * external code. Has a word `Instance` in the name to avoid confusion with
+ * {@linkcode EMIDIAccess|EMIDIAccess.EMIDIAccess} context tag.
+ */
+export interface EMIDIAccessInstance extends Equal.Equal, Pipeable.Pipeable, Inspectable.Inspectable {
+    readonly [TypeId]: TypeId;
+    readonly _tag: 'EMIDIAccess';
+    /**
+     * The **`sysexEnabled`** read-only property of the MIDIAccess interface indicates whether system exclusive support is enabled on the current MIDIAccess instance.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MIDIAccess/sysexEnabled)
+     */
+    readonly sysexEnabled: boolean;
+    readonly softwareSynthEnabled: boolean;
+}
+/**
+ * Thin wrapper around raw {@linkcode MIDIAccess} instance giving access to the
+ * actual field storing it. Has a word `Instance` in the name to avoid confusion
+ * with {@linkcode EMIDIAccess|EMIDIAccess.EMIDIAccess} context tag.
+ * @internal
+ */
+interface EMIDIAccessImplementationInstance extends EMIDIAccessInstance {
+    readonly _access: MIDIAccess;
+    readonly _config: Readonly<RequestMIDIAccessOptions>;
+}
+/**
+ * Asserts that an `unknown` value is a valid {@linkcode EMIDIAccessInstance|EMIDIAccess.Instance}
+ * and casts it to the type. Throws an error if the assertion fails.
+ *
+ * @internal
+ * @example
+ * ```ts
+ * import * as EMIDIAccess from 'effect-web-midi/EMIDIAccess';
+ *
+ * const unknownValue: null | EMIDIAccess.Instance = null
+ *
+ * try {
+ *   const validatedAccess = EMIDIAccess.assert(unknownValue);
+ *   // validatedAccess is now known to be EMIDIAccess.Instance
+ * } catch (error) {
+ *   console.error("Assertion failed:", error);
+ * }
+ * ```
+ *
+ * @see {@linkcode is|EMIDIAccess.is}
+ */
+export declare const assert: (access: unknown) => EMIDIAccessInstance;
+/**
+ * Purely a type-level typecast to expose internal fields. Does no runtime
+ * validation and assumes you provided
+ * {@linkcode EMIDIAccessInstance|EMIDIAccess.Instance} acquired legitimately
+ * from `effect-web-midi`.
+ *
+ * @internal
+ * @example
+ * ```ts
+ * // Assume `accessInstance` is known to be an internal implementation
+ * declare const accessPublic: EMIDIAccessInstance;
+ * const accessInternal = assumeImpl(accessPublic);
+ * console.log('No type error here: ', accessInternal._config)
+ * ```
+ */
+export declare const assumeImpl: (access: EMIDIAccessInstance) => EMIDIAccessImplementationInstance;
+/**
+ * @example
+ * ```ts
+ * import * as EMIDIAccess from 'effect-web-midi/EMIDIAccess';
+ *
+ * const accessOrNot: null | EMIDIAccess.Instance = null
+ *
+ * if (EMIDIAccess.is(accessOrNot)) {
+ *   const accessPublic = accessOrNot;
+ *   // ts-expect-error You're exposed only to public facing fields
+ *   console.log(accessPublic._config)
+ *   // will not be logged
+ * } else {
+ *   console.log('This will be logged because null is not EMIDIAccessInstance')
+ * }
+ * ```
+ *
+ * @see {@linkcode assert|EMIDIAccess.assert}
+ */
+export declare const is: (access: unknown) => access is EMIDIAccessInstance;
+/**
+ * This utility function is used internally to handle different ways MIDI access
+ * might be provided, ensuring a consistent type for further operations. It uses
+ * the public {@linkcode is|EMIDIAccess.is} type guard for validation. If an
+ * effect is passed, errors and requirements are passed-through without
+ * modifications.
+ *
+ * @internal
+ * @param polymorphicAccess Either just {@linkcode EMIDIAccessInstance|EMIDIAccess.Instance}, or an
+ * Effect having it in the success channel.
+ * @returns An effect with type-asserted at runtime
+ * {@linkcode EMIDIAccessInstance|EMIDIAccess.Instance}.
+ *
+ * @example
+ * ```ts
+ * import * as Effect from 'effect/Effect';
+ * import * as EMIDIAccess from 'effect-web-midi/EMIDIAccess';
+ *
+ * const getValidatedAccess = Effect.gen(function* () {
+ *   // Assume `polymorphicAccess` is obtained elsewhere
+ *   const polymorphicAccess = {} as EMIDIAccess.PolymorphicInstance;
+ *   const validatedAccess = yield* EMIDIAccess.simplify(polymorphicAccess);
+ *   // The operation above will throw a defect, because {} is not an access instance
+ *   return validatedAccess;
+ * });
+ * ```
+ *
+ * @see {@linkcode Util.fromPolymorphic}
+ * @see {@linkcode PolymorphicAccessInstance|EMIDIAccess.PolymorphicInstance}
+ * @see {@linkcode PolymorphicAccessInstanceClean|EMIDIAccess.PolymorphicCleanInstance}
+ */
+export declare const simplify: <E = never, R = never>(polymorphicAccess: PolymorphicAccessInstance<E, R>) => Effect.Effect<EMIDIAccessInstance, E, R>;
+/**
+ * Represents a MIDI access instance that can be provided polymorphically:
+ * directly as a value ({@linkcode EMIDIAccessInstance|EMIDIAccess.Instance}),
+ * or wrapped in effect. Typically processed by
+ * {@linkcode simplify|EMIDIAccess.simplify}.
+ *
+ * @template E The type of errors that can be thrown while acquiring the access.
+ * @template R The environment required to simplify the access.
+ *
+ * @example
+ * ```ts
+ * import * as Effect from 'effect/Effect';
+ * import * as EMIDIAccess from 'effect-web-midi/EMIDIAccess';
+ * import type * as MIDIErrors from 'effect-web-midi/MIDIErrors';
+ *
+ * let polymorphicAccess: EMIDIAccess.PolymorphicInstance<
+ *   | MIDIErrors.MIDIAccessNotAllowedError
+ *   | MIDIErrors.MIDIAccessNotSupportedError,
+ *   never
+ * > = EMIDIAccess.request().pipe(
+ *   Effect.catchTag('AbortError', 'UnderlyingSystemError', () =>
+ *     Effect.dieMessage('YOLO'),
+ *   ),
+ * )
+ *
+ * if (Effect.isEffect(polymorphicAccess)) {
+ *   const access: EMIDIAccess.Instance = await Effect.runPromise(polymorphicAccess)
+ *   // Assignment of plain instance works just fine
+ *   polymorphicAccess = access
+ * }
+ * ```
+ *
+ * @see {@linkcode simplify|EMIDIAccess.simplify}
+ * @see {@linkcode PolymorphicAccessInstanceClean|EMIDIAccess.PolymorphicCleanInstance}
+ */
+export type PolymorphicAccessInstance<E, R> = Util.PolymorphicEffect<EMIDIAccessInstance, E, R>;
+/**
+ * Represents a MIDI access instance that can be provided polymorphically:
+ * directly as a value ({@linkcode EMIDIAccessInstance|EMIDIAccess.Instance}),
+ * or wrapped in effect that never fails and doesn't require any context.
+ * Typically processed by {@linkcode simplify|EMIDIAccess.simplify}.
+ *
+ * @example
+ * ```ts
+ * import * as Effect from 'effect/Effect';
+ * import * as EMIDIAccess from 'effect-web-midi/EMIDIAccess';
+ *
+ * let polymorphicAccess: EMIDIAccess.PolymorphicCleanInstance =
+ *   Effect.orDie(EMIDIAccess.request())
+ *
+ * if (Effect.isEffect(polymorphicAccess)) {
+ *   const access: EMIDIAccess.Instance =
+ *     await Effect.runPromise(polymorphicAccess)
+ *   // Assignment of plain instance works just fine
+ *   polymorphicAccess = access
+ * }
+ * ```
+ *
+ * @see {@linkcode simplify|EMIDIAccess.simplify}
+ * @see {@linkcode PolymorphicAccessInstance|EMIDIAccess.PolymorphicInstance}
+ */
+export type PolymorphicAccessInstanceClean = PolymorphicAccessInstance<never, never>;
+/**
+ * Interface for functions that retrieve a port record from polymorphic access.
+ */
+export interface GetPortRecordFromPolymorphicAccess<RecordEntries extends UnknownEntriesUnion> {
+    /**
+     * @param polymorphicAccess Optionally wrapped in effect {@linkcode EMIDIAccessInstance|EMIDIAccess.Instance}.
+     * @returns Effect with `Record` of MIDI port ids mapped to according effectful ports
+     */
+    <E = never, R = never>(polymorphicAccess: PolymorphicAccessInstance<E, R>): Effect.Effect<EntriesToRecord<RecordEntries>, E, R>;
+}
+/**
+ * Utility type to convert union of entries to a record type.
+ *
+ * @template Entries The union of entry tuples.
+ */
+export type EntriesToRecord<Entries extends UnknownEntriesUnion> = Types.UnionToIntersection<Entries extends unknown ? Record<Entries[0], Entries[1]> : never>;
+/**
+ * Placeholder tuple representing `Record` entry
+ */
+export type UnknownEntriesUnion = [string, unknown];
+/**
+ * Because `MIDIInputMap` can potentially be a mutable object, meaning new
+ * devices can be added or removed at runtime, it is effectful.
+ *
+ * The **`inputs`** read-only property of the MIDIAccess interface provides
+ * access to any available MIDI input ports.
+ *
+ * [MDN
+ * Reference](https://developer.mozilla.org/docs/Web/API/MIDIAccess/inputs)
+ */
+export declare const getInputsRecord: GetPortRecordFromPolymorphicAccess<InputRecordEntry>;
+type InputRecordEntry = [EMIDIInput.Id, EMIDIInput.EMIDIInput];
+/**
+ * Because `MIDIOutputMap` can potentially be a mutable object, meaning new
+ * devices can be added or removed at runtime, it is effectful.
+ *
+ * The **`outputs`** read-only property of the MIDIAccess interface provides
+ * access to any available MIDI output ports.
+ *
+ * [MDN
+ * Reference](https://developer.mozilla.org/docs/Web/API/MIDIAccess/outputs)
+ */
+export declare const getOutputsRecord: GetPortRecordFromPolymorphicAccess<OutputRecordEntry>;
+type OutputRecordEntry = [EMIDIOutput.Id, EMIDIOutput.EMIDIOutput];
+/**
+ *
+ *
+ */
+export declare const getAllPortsRecord: GetPortRecordFromPolymorphicAccess<AllPortEntryUnion>;
+type AllPortEntryUnion = InputRecordEntry | OutputRecordEntry;
+export interface InputsRecordInContextEffect extends Effect.Effect<EMIDIInput.InputIdToInstanceMap, never, EMIDIAccess> {
+}
+/**
+ *
+ *
+ */
+export declare const InputsRecord: InputsRecordInContextEffect;
+export interface OutputsRecordInContextEffect extends Effect.Effect<EMIDIOutput.OutputIdToInstanceMap, never, EMIDIAccess> {
+}
+/**
+ *
+ *
+ */
+export declare const OutputsRecord: OutputsRecordInContextEffect;
+export interface AllPortsRecordInContextEffect extends Effect.Effect<EMIDIPort.BothIdToBothInstanceMap, never, EMIDIAccess> {
+}
+/**
+ *
+ *
+ */
+export declare const AllPortsRecord: AllPortsRecordInContextEffect;
+export interface GetPortArrayFromPolymorphicAccess<Port> {
+    /**
+     *
+     */
+    <E = never, R = never>(polymorphicAccess: PolymorphicAccessInstance<E, R>): Effect.Effect<Port[], E, R>;
+}
+/**
+ * Because `MIDIInputMap` can potentially be a mutable object, meaning new
+ * devices can be added or removed at runtime, it is effectful.
+ *
+ * The **`inputs`** read-only property of the MIDIAccess interface provides
+ * access to any available MIDI input ports.
+ *
+ * [MDN
+ * Reference](https://developer.mozilla.org/docs/Web/API/MIDIAccess/inputs)
+ */
+export declare const getInputsArray: GetPortArrayFromPolymorphicAccess<EMIDIInput.EMIDIInput>;
+/**
+ * Because `MIDIOutputMap` can potentially be a mutable object, meaning new
+ * devices can be added or removed at runtime, it is effectful.
+ *
+ * The **`outputs`** read-only property of the MIDIAccess interface provides
+ * access to any available MIDI output ports.
+ *
+ * [MDN
+ * Reference](https://developer.mozilla.org/docs/Web/API/MIDIAccess/outputs)
+ */
+export declare const getOutputsArray: GetPortArrayFromPolymorphicAccess<EMIDIOutput.EMIDIOutput>;
+/**
+ *
+ *
+ */
+export declare const getAllPortsArray: GetPortArrayFromPolymorphicAccess<EMIDIOutput.EMIDIOutput | EMIDIInput.EMIDIInput>;
+export interface InputsArrayInContextEffect extends Effect.Effect<EMIDIInput.EMIDIInput[], never, EMIDIAccess> {
+}
+/**
+ *
+ *
+ */
+export declare const InputsArray: InputsArrayInContextEffect;
+export interface OutputsArrayInContextEffect extends Effect.Effect<EMIDIOutput.EMIDIOutput[], never, EMIDIAccess> {
+}
+/**
+ *
+ *
+ */
+export declare const OutputsArray: OutputsArrayInContextEffect;
+export interface AllPortsArrayInContextEffect extends Effect.Effect<(EMIDIOutput.EMIDIOutput | EMIDIInput.EMIDIInput)[], never, EMIDIAccess> {
+}
+/**
+ *
+ *
+ */
+export declare const AllPortsArray: AllPortsArrayInContextEffect;
+/**
+ * [MIDIConnectionEvent MDN
+ * Reference](https://developer.mozilla.org/docs/Web/API/MIDIConnectionEvent)
+ */
+export declare const makeAllPortsStateChangesStream: StreamMaker.DualStreamMaker<EMIDIAccessInstance, "MIDIPortStateChange", {
+    readonly newState: {
+        readonly ofDevice: MIDIPortDeviceState;
+        readonly ofConnection: MIDIPortConnectionState;
+    } | null;
+    readonly port: EMIDIInput.EMIDIInput | EMIDIOutput.EMIDIOutput | null;
+}>;
+/**
+ * beware that it's not possible to ensure the messages will either be all
+ * delivered, or all not delivered, as in ACID transactions. There's not even a
+ * mechanism to remove a specific message (not all) from the sending queue
+ */
+export declare const send: DualSendMIDIMessageFromAccess;
+/**
+ * @param options Passing a value of a `boolean` type is equivalent to setting
+ * `options.capture` property
+ */
+export declare const makeMessagesStreamByInputId: <const TOnNullStrategy extends StreamMaker.OnNullStrategy = undefined>(id: EMIDIInput.Id, options?: StreamMaker.StreamMakerOptions<TOnNullStrategy>) => StreamMaker.BuiltStream<"MIDIMessage", EMIDIInput.EMIDIInput, {
+    midiMessage: Uint8Array<ArrayBuffer> | null;
+}, TOnNullStrategy, MIDIErrors.PortNotFoundError, EMIDIAccess>;
+export declare const makeMessagesStreamByInputIdAndAccess: () => never;
+/**
+ *
+ */
+export declare const sendToPortById: (id: EMIDIOutput.Id, ...args: EMIDIOutput.SendFromPortArgs) => Effect.Effect<void, MIDIErrors.CannotSendSysexMessageError | MIDIErrors.CannotSendToDisconnectedPortError | MIDIErrors.MalformedMIDIMessageError | MIDIErrors.PortNotFoundError, EMIDIAccess>;
+/**
+ *
+ */
+export declare const clearPortById: (id: string & import("effect/Brand").Brand<"MIDIPortId"> & import("effect/Brand").Brand<"output">) => Effect.Effect<void, MIDIErrors.ClearingSendingQueueIsNotSupportedError | MIDIErrors.PortNotFoundError, EMIDIAccess>;
+/**
+ * @param options Passing a value of a `boolean` type is equivalent to setting
+ * `options.capture` property
+ */
+export declare const makeAllPortsStateChangesStreamInContext: <const TOnNullStrategy extends StreamMaker.OnNullStrategy = undefined>(options?: StreamMaker.StreamMakerOptions<TOnNullStrategy>) => StreamMaker.BuiltStream<"MIDIPortStateChange", EMIDIAccessInstance, {
+    readonly newState: {
+        readonly ofDevice: MIDIPortDeviceState;
+        readonly ofConnection: MIDIPortConnectionState;
+    } | null;
+    readonly port: EMIDIInput.EMIDIInput | EMIDIOutput.EMIDIOutput | null;
+}, TOnNullStrategy, never, EMIDIAccess>;
+/**
+ *
+ *
+ */
+export declare const sendInContext: (...args: SendFromAccessArgs) => Effect.Effect<void, MIDIErrors.CannotSendSysexMessageError | MIDIErrors.CannotSendToDisconnectedPortError | MIDIErrors.MalformedMIDIMessageError, EMIDIAccess>;
+/**
+ * @param options
+ *
+ * @returns An Effect representing a request for access to MIDI devices on a
+ * user's system. Available only in secure contexts.
+ */
+export declare const request: (options?: RequestMIDIAccessOptions | undefined) => Effect.Effect<EMIDIAccessInstance, MIDIErrors.AbortError | MIDIErrors.MIDIAccessNotAllowedError | MIDIErrors.MIDIAccessNotSupportedError | MIDIErrors.UnderlyingSystemError, never>;
+/**
+ *
+ * **Errors:**
+ *
+ * - {@linkcode MIDIErrors.AbortError} Description
+ * - {@linkcode MIDIErrors.UnderlyingSystemError} Description
+ * - {@linkcode MIDIErrors.MIDIAccessNotSupportedError} Description
+ * - {@linkcode MIDIErrors.MIDIAccessNotAllowedError} Description
+ *
+ * @param config
+ * @returns
+ */
+export declare const layer: (config?: RequestMIDIAccessOptions) => Layer.Layer<EMIDIAccess, MIDIErrors.AbortError | MIDIErrors.MIDIAccessNotAllowedError | MIDIErrors.MIDIAccessNotSupportedError | MIDIErrors.UnderlyingSystemError, never>;
+/**
+ *
+ */
+export declare const layerMostRestricted: Layer.Layer<EMIDIAccess, MIDIErrors.AbortError | MIDIErrors.MIDIAccessNotAllowedError | MIDIErrors.MIDIAccessNotSupportedError | MIDIErrors.UnderlyingSystemError, never>;
+/**
+ *
+ */
+export declare const layerSystemExclusiveSupported: Layer.Layer<EMIDIAccess, MIDIErrors.AbortError | MIDIErrors.MIDIAccessNotAllowedError | MIDIErrors.MIDIAccessNotSupportedError | MIDIErrors.UnderlyingSystemError, never>;
+/**
+ *
+ */
+export declare const layerSoftwareSynthSupported: Layer.Layer<EMIDIAccess, MIDIErrors.AbortError | MIDIErrors.MIDIAccessNotAllowedError | MIDIErrors.MIDIAccessNotSupportedError | MIDIErrors.UnderlyingSystemError, never>;
+/**
+ *
+ */
+export declare const layerSystemExclusiveAndSoftwareSynthSupported: Layer.Layer<EMIDIAccess, MIDIErrors.AbortError | MIDIErrors.MIDIAccessNotAllowedError | MIDIErrors.MIDIAccessNotSupportedError | MIDIErrors.UnderlyingSystemError, never>;
+export interface SentMessageEffectFromAccess<E = never, R = never> extends Util.SentMessageEffectFrom<EMIDIAccessInstance, E, R> {
+}
+export type TargetPortSelector = 'all existing outputs at effect execution' | 'all open connections at effect execution' | EMIDIOutput.Id | EMIDIOutput.Id[];
+export interface DualSendMIDIMessageFromAccess extends SendMIDIMessageAccessFirst, SendMIDIMessageAccessLast {
+}
+export type SendFromAccessArgs = [
+    targetPortSelector: TargetPortSelector,
+    ...args: EMIDIOutput.SendFromPortArgs
+];
+export interface SendMIDIMessageAccessFirst {
+    /**
+     *
+     *
+     */
+    <E = never, R = never>(polymorphicAccess: PolymorphicAccessInstance<E, R>, ...args: SendFromAccessArgs): SentMessageEffectFromAccess<E, R>;
+}
+export interface SendMIDIMessageAccessLast {
+    /**
+     *
+     *
+     */
+    (...args: SendFromAccessArgs): {
+        /**
+         *
+         *
+         */
+        <E = never, R = never>(polymorphicAccess: PolymorphicAccessInstance<E, R>): SentMessageEffectFromAccess<E, R>;
+    };
+}
+export interface GetThingByPortId<TSuccess, TTypeOfPortId extends MIDIPortType, TAccessGettingFallbackError, TAccessGettingFallbackRequirement, TAdditionalError, TAdditionalRequirement> extends GetThingByPortIdAccessFirst<TSuccess, TTypeOfPortId, TAccessGettingFallbackError, TAccessGettingFallbackRequirement, TAdditionalError, TAdditionalRequirement>, GetThingByPortIdAccessLast<TSuccess, TTypeOfPortId, TAccessGettingFallbackError, TAccessGettingFallbackRequirement, TAdditionalError, TAdditionalRequirement> {
+}
+export interface GetThingByPortIdAccessFirst<TSuccess, TTypeOfPortId extends MIDIPortType, TAccessGettingFallbackError, TAccessGettingFallbackRequirement, TAdditionalError, TAdditionalRequirement> {
+    /**
+     *
+     *
+     */
+    <TAccessGettingError = never, TAccessGettingRequirement = never>(polymorphicAccess: PolymorphicAccessInstance<TAccessGettingError, TAccessGettingRequirement>, id: EMIDIPort.Id<TTypeOfPortId>): AcquiredThing<TSuccess, TAccessGettingError, TAccessGettingRequirement, TAccessGettingFallbackError, TAccessGettingFallbackRequirement, TAdditionalError, TAdditionalRequirement>;
+}
+export interface GetThingByPortIdAccessLast<TSuccess, TTypeOfPortId extends MIDIPortType, TAccessGettingFallbackError, TAccessGettingFallbackRequirement, TAdditionalError, TAdditionalRequirement> {
+    /**
+     *
+     *
+     */
+    (id: EMIDIPort.Id<TTypeOfPortId>): GetThingByPortIdAccessLastSecondHalf<TSuccess, TAccessGettingFallbackError, TAccessGettingFallbackRequirement, TAdditionalError, TAdditionalRequirement>;
+}
+export interface GetThingByPortIdAccessLastSecondHalf<TSuccess, TAccessGettingFallbackError, TAccessGettingFallbackRequirement, TAdditionalError, TAdditionalRequirement> {
+    /**
+     *
+     *
+     */
+    <TAccessGettingError = never, TAccessGettingRequirement = never>(polymorphicAccess: PolymorphicAccessInstance<TAccessGettingError, TAccessGettingRequirement>): AcquiredThing<TSuccess, TAccessGettingError, TAccessGettingRequirement, TAccessGettingFallbackError, TAccessGettingFallbackRequirement, TAdditionalError, TAdditionalRequirement>;
+}
+export interface AcquiredThing<TSuccess, TAccessGettingError, TAccessGettingRequirement, TAccessGettingFallbackError, TAccessGettingFallbackRequirement, TAdditionalError, TAdditionalRequirement> extends Effect.Effect<TSuccess, Util.FallbackOnUnknownOrAny<TAccessGettingError, TAccessGettingFallbackError> | TAdditionalError, Util.FallbackOnUnknownOrAny<TAccessGettingRequirement, TAccessGettingFallbackRequirement> | TAdditionalRequirement> {
+}
+export {};
+//# sourceMappingURL=EMIDIAccess.d.ts.map

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

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

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

@@ -0,0 +1,50 @@
+import * as Brand from 'effect/Brand';
+import * as EMIDIPort from './EMIDIPort.ts';
+import * as StreamMaker from './StreamMaker.ts';
+/**
+ * Thin wrapper around {@linkcode MIDIInput} instance. Will be seen in all
+ * external code.
+ */
+export interface EMIDIInput extends EMIDIPort.EMIDIPort<'input'> {
+}
+/**
+ * Asserts an object to be valid EMIDIInput
+ */
+export declare const assert: (input: unknown) => EMIDIInput;
+/**
+ *
+ *
+ * @internal
+ */
+export declare const make: (rawInput: MIDIInput) => EMIDIInput;
+/**
+ *
+ *
+ */
+export declare const is: (input: unknown) => input is EMIDIInput;
+/**
+ * [MIDIMessageEvent MDN
+ * Reference](https://developer.mozilla.org/docs/Web/API/MIDIMessageEvent)
+ *
+ * MIDI spec says that synthetically built `MIDIMessageEvent`s can have `data`
+ * field equal to `null`, but when coming from the browser, they won't. The
+ * default behavior is to defect on `null`.
+ */
+export declare const makeMessagesStreamByPort: StreamMaker.DualStreamMaker<EMIDIInput, "MIDIMessage", {
+    midiMessage: Uint8Array<ArrayBuffer> | null;
+}>;
+/**
+ *
+ *
+ */
+export type PolymorphicInput<E, R> = EMIDIPort.PolymorphicPort<E, R, 'input'>;
+/**
+ *
+ *
+ */
+export type PolymorphicInputClean = EMIDIPort.PolymorphicPortClean<'input'>;
+export type Id = EMIDIPort.Id<'input'>;
+export declare const Id: Brand.Brand.Constructor<string & Brand.Brand<"MIDIPortId"> & Brand.Brand<"input">>;
+export interface InputIdToInstanceMap extends Record<Id, EMIDIInput> {
+}
+//# sourceMappingURL=EMIDIInput.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EMIDIInput.d.ts","sourceRoot":"","sources":["../../../src/internal/EMIDIInput.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAErC,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAC3C,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAQ/C;;;GAGG;AACH,MAAM,WAAW,UAAW,SAAQ,SAAS,CAAC,SAAS,CAAC,OAAO,CAAC;CAAG;AA6BnE;;GAEG;AACH,eAAO,MAAM,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,UAAuB,CAAA;AAOhE;;;;GAIG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,QAAQ,EAAE,SAAS,KAAK,UAAqB,CAAA;AAUjE;;;GAGG;AACH,eAAO,MAAM,EAAE,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,KAAK,IAAI,UAAmB,CAAA;AAEjE;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB;;EAalC,CAAA;AAEH;;;GAGG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,EAAE,CAAC,IAAI,SAAS,CAAC,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAA;AAE7E;;;GAGG;AACH,MAAM,MAAM,qBAAqB,GAAG,SAAS,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAA;AAE3E,MAAM,MAAM,EAAE,GAAG,SAAS,CAAC,EAAE,CAAC,OAAO,CAAC,CAAA;AACtC,eAAO,MAAM,EAAE,oFAAsB,CAAA;AAErC,MAAM,WAAW,oBAAqB,SAAQ,MAAM,CAAC,EAAE,EAAE,UAAU,CAAC;CAAG"}