@scrypted/server 0.144.0 → 0.144.2

package/src/db-types.ts

@@ -2,8 +2,8 @@ import { LevelDocument } from "./level";
 import { ScryptedNativeId, SystemDeviceState } from "@scrypted/types";
 
 export class ScryptedDocument implements LevelDocument {
-    _id?: string;
-    _documentType?: string;
+    _id!: string;
+    _documentType!: string;
 }
 
 export class Settings extends ScryptedDocument {
@@ -16,28 +16,28 @@ export class Plugin extends ScryptedDocument {
 }
 
 export class ScryptedUser extends ScryptedDocument {
-    passwordDate: number;
-    passwordHash: string;
-    token: string;
-    salt: string;
-    aclId: string;
+    passwordDate!: number;
+    passwordHash!: string;
+    token!: string;
+    salt!: string;
+    aclId?: string;
 }
 
 export class ScryptedAlert extends ScryptedDocument {
-    timestamp: number;
-    title: string;
-    path: string;
-    message: string;
+    timestamp!: number;
+    title!: string;
+    path!: string;
+    message!: string;
 }
 
 export class PluginDevice extends ScryptedDocument {
-    constructor(id?: string) {
+    constructor(id: string) {
         super();
         this._id = id;
     }
     nativeId: ScryptedNativeId;
-    pluginId: string;
-    state: { [property: string]: SystemDeviceState };
-    stateVersion: number;
-    storage: { [key: string]: string };
+    pluginId!: string;
+    state!: { [property: string]: SystemDeviceState };
+    stateVersion!: number;
+    storage!: { [key: string]: string };
 }

package/src/event-registry.ts

@@ -29,10 +29,11 @@ export class EventRegistry {
 
     listen(callback: (id: string, eventDetails: EventDetails, eventData: any) => void): EventListenerRegister {
         const events = this.systemListeners;
-        events.add(callback);
+        let cb: typeof callback | undefined = callback;
+        events.add(cb);
         return new EventListenerRegisterImpl(() => {
-            events.delete(callback);
-            callback = undefined;
+            events.delete(cb!);
+            cb = undefined;
         });
     }
 
@@ -45,14 +46,15 @@ export class EventRegistry {
             this.listeners[token] = events;
         }
 
-        events.add(callback);
+        let cb: typeof callback | undefined = callback;
+        events.add(cb);
         return new EventListenerRegisterImpl(() => {
-            events.delete(callback);
-            callback = undefined;
+            events.delete(cb!);
+            cb = undefined;
         });
     }
 
-    notify(id: string | undefined, eventTime: number, eventInterface: string, property: string | undefined, value: any, options?: {
+    notify(id: string | undefined, eventTime: number | undefined, eventInterface: string, property: string | undefined, value: any, options?: {
         changed?: boolean;
         mixinId?: string;
     }): boolean {
@@ -62,9 +64,9 @@ export class EventRegistry {
             return false;
 
         const eventDetails: EventDetails = {
-            eventId: undefined,
+            eventId: undefined!,
             eventInterface,
-            eventTime,
+            eventTime: eventTime!,
             property,
             mixinId,
         };
@@ -79,9 +81,9 @@ export class EventRegistry {
         // system listeners only get state changes.
         // there are many potentially noisy stateless events, like
         // object detection and settings changes.
-        if ((eventDetails.property && !eventDetails.mixinId) || allowedEventInterfaces.has(eventInterface)) {
+        if ((eventDetails.property && !eventDetails.mixinId) || allowedEventInterfaces.has(eventInterface!)) {
             for (const event of this.systemListeners) {
-                event(id, eventDetails, value);
+                event(id!, eventDetails, value);
             }
         }
 

package/src/fetch/index.ts

@@ -66,14 +66,14 @@ export type fetcher<B, M> = <T extends HttpFetchOptions<B>>(options: T) => Promi
 >>;
 
 
-export function getHttpFetchAccept(responseType: HttpFetchResponseType | undefined) {
+export function getHttpFetchAccept(responseType: HttpFetchResponseType | undefined): string | undefined {
     switch (responseType) {
         case 'json':
             return 'application/json';
         case 'text':
             return 'text/plain';
     }
-    return;
+    return undefined;
 }
 
 export function hasHeader(headers: [string, string][], key: string) {
@@ -119,10 +119,7 @@ export function createHeadersArray(headers: HeadersInit | undefined): [string, s
         return headersArray;
     }
 
-    for (const k of Object.keys(headers)) {
-        const v = headers[k];
-        headersArray.push([k, v]);
-    }
+    headersArray.push(...Object.entries(headers));
 
     return headersArray;
 }
@@ -135,7 +132,7 @@ export function createHeadersArray(headers: HeadersInit | undefined): [string, s
  */
 export function createStringOrBufferBody(headers: [string, string][], body: any) {
     let contentType: string | undefined;
-    if (typeof body === 'object') {
+    if (typeof body === 'object' && !ArrayBuffer.isView(body)) {
         body = JSON.stringify(body);
         contentType = 'application/json';
     }

package/src/http-interfaces.ts

@@ -63,7 +63,7 @@ export class HttpResponseImpl implements HttpResponse {
 
         // prefer etag
         this.res.sendFile(filePath, {
-            root: null,
+            root: undefined,
             dotfiles: 'allow',
             cacheControl: false,
         });
@@ -110,7 +110,7 @@ export class HttpResponseImpl implements HttpResponse {
                 this.res.end();
             }
             catch (e) {
-                this.res.destroy(e);
+                this.res.destroy(e as Error);
             }
             finally {
                 peer.kill();

package/src/infer-defaults.ts

@@ -36,12 +36,16 @@ addType(ScryptedInterface.HttpRequestHandler, ScryptedDeviceType.DataSource);
 addType(ScryptedInterface.BufferConverter, ScryptedDeviceType.API);
 addType(ScryptedInterface.DeviceProvider, ScryptedDeviceType.DeviceProvider);
 
-export function inferTypeFromInterfaces(interfaces: ScryptedInterface[]): ScryptedDeviceType {
+export function inferTypeFromInterfaces(interfaces: ScryptedInterface[]): ScryptedDeviceType | undefined {
     return inferTypesFromInterfaces(interfaces)[0];
 }
 
 export function inferTypesFromInterfaces(interfaces: ScryptedInterface[]): ScryptedDeviceType[] {
-    const types = Object.keys(inferenceTable).filter(iface => interfaces.includes(iface as ScryptedInterface)).map(iface => inferenceTable[iface]).flat();
+    const types = Object.keys(inferenceTable)
+        .filter(iface => interfaces.includes(iface as ScryptedInterface))
+        .map(iface => inferenceTable[iface])
+        .filter((types): types is ScryptedDeviceType[] => types !== undefined)
+        .flat();
     return types;
 }
 
@@ -96,24 +100,24 @@ const roomHints: { [hint: string]: string } = {
     'Laundry': 'Laundry Room',
 }
 
-export function inferRoomFromName(name: string): string {
+export function inferRoomFromName(name: string): string | undefined {
     if (!name)
-        return;
+        return undefined;
     for (const hint of Object.keys(roomHints)) {
         if (name.includes(hint))
             return roomHints[hint];
     }
+    return undefined;
 }
 
-export function getProvidedRoomOrDefault(pluginDevice: PluginDevice): string {
+export function getProvidedRoomOrDefault(pluginDevice: PluginDevice): string | undefined {
     const providedRoom = getState(pluginDevice, ScryptedInterfaceProperty.providedRoom);
     if (providedRoom)
         return providedRoom;
-    const room = inferRoomFromName(getDisplayName(pluginDevice));
-    return room;
+    return inferRoomFromName(getDisplayName(pluginDevice));
 }
 
-export function getDisplayRoom(pluginDevice: PluginDevice): string {
+export function getDisplayRoom(pluginDevice: PluginDevice): string | undefined {
     const room = getState(pluginDevice, ScryptedInterfaceProperty.room);
     if (room)
         return room;

package/src/ip.ts

@@ -70,6 +70,7 @@ export function getUsableNetworkAddresses() {
     const getUsable = (family: string | number) => {
         const usable = Object.values(nis)
             .flat()
+            .filter((details): details is os.NetworkInterfaceInfo => !!details)
             .filter((details) => details.family === family)
             .filter(details => isUsableNetworkAddress(details.address));
         return usable;
@@ -84,7 +85,7 @@ export function getUsableNetworkAddresses() {
     const fixedAddresses = ipv6.filter(details => details.address.includes('::'));
     const fixedRanges = fixedAddresses.map(details => {
         const block = new net.BlockList();
-        const cidr = parseInt(details.address.split('/')[1]) || 1;
+        const cidr = parseInt(details.address.split('/')[1] ?? '') || 1;
         block.addSubnet(details.address, cidr, 'ipv6');
         return block;
     });

package/src/level.ts

@@ -1,8 +1,8 @@
 import { GetOptions, Level, OpenOptions, PutOptions } from 'level';
 
 export interface LevelDocument {
-    _id?: any;
-    _documentType?: string;
+    _id: any;
+    _documentType: string;
 }
 
 export interface LevelDocumentConstructor<T extends LevelDocument> {
@@ -16,11 +16,11 @@ function createLevelDocument(documentConstructor: any, json: any) {
 }
 
 export class WrappedLevel extends Level<string, string | number> {
-    curId: number;
+    curId!: number;
 
-    async open(): Promise<void>;
-    async open(options?: OpenOptions): Promise<void> {
-        await super.open(options);
+    override async open(): Promise<void>;
+    override async open(options?: OpenOptions): Promise<void> {
+        await super.open(options!);
         try {
             this.curId = parseInt(await this.get('_id') as string);
         }
@@ -31,14 +31,15 @@ export class WrappedLevel extends Level<string, string | number> {
     }
 
 
-    async tryGet<T>(documentConstructor: new () => T, _id: any, options?: GetOptions<string, string | number>): Promise<T> {
+    async tryGet<T>(documentConstructor: new () => T, _id: any, options?: GetOptions<string, string | number>): Promise<T | undefined> {
         try {
             const _documentType = documentConstructor.name;
             const key = `${_documentType}/${_id}`;
-            const json = await this.get(key, options)
+            const json = await this.get(key, options!)
             return createLevelDocument(documentConstructor, json);
         }
         catch (e) {
+            return undefined;
         }
     }
 
@@ -82,7 +83,7 @@ export class WrappedLevel extends Level<string, string | number> {
 
         value._documentType = _documentType;
         const key = `${_documentType}/${value._id}`;
-        await this.put(key, JSON.stringify(value), options);
+        await this.put(key, JSON.stringify(value), options!);
         return value;
     };
 

package/src/listen-zero.ts

@@ -18,7 +18,7 @@ export async function listenZeroSingleClient(hostname: string, options?: net.Ser
     const server = options?.tls ? new tls.Server(options) : new net.Server(options);
     const port = await listenZero(server, hostname);
 
-    let cancel: () => void;
+    let cancel!: () => void;
     const clientPromise = new Promise<net.Socket>((resolve, reject) => {
         const timeout = setTimeout(() => {
             server.close();

package/src/mixin/mixin-cycle.ts

@@ -10,22 +10,22 @@ export function getMixins(scrypted: ScryptedRuntime, id: string) {
 }
 
 export function hasMixinCycle(scrypted: ScryptedRuntime, id: string, mixins?: string[]) {
-    mixins = mixins || getMixins(scrypted, id);
+    let mixinsList = mixins || getMixins(scrypted, id);
 
     // given the mixins for a device, find all the mixins for those mixins,
     // and create a visited graph.
     // if the visited graphs includes the original device, that indicates
     // a cyclical dependency for that device.
-    const visitedMixins = new Set(mixins);
+    const visitedMixins = new Set(mixinsList);
 
-    mixins = mixins.slice();
-    while (mixins.length) {
-        const mixin = mixins.pop();
+    mixinsList = mixinsList.slice();
+    while (mixinsList.length) {
+        const mixin = mixinsList.pop()!;
         if (visitedMixins.has(mixin))
             continue;
         visitedMixins.add(mixin);
         const providerMixins = getMixins(scrypted, mixin);
-        mixins.push(...providerMixins);
+        mixinsList.push(...providerMixins);
     }
 
     return visitedMixins.has(id);

package/src/plugin/acl.ts

@@ -61,7 +61,7 @@ export class AccessControls {
         const { eventInterface } = eventDetails;
 
         for (const dacl of dacls) {
-            if (!dacl.interfaces || dacl.interfaces.includes(eventInterface))
+            if (!dacl.interfaces || dacl.interfaces.includes(eventInterface!))
                 return false;
         }
 

package/src/plugin/cluster.ts

@@ -6,7 +6,7 @@ export interface ClusterForkServiceInterface {
 }
 
 export class ClusterManagerImpl implements ClusterManager {
-    private clusterServicePromise: Promise<ClusterForkServiceInterface>;
+    private clusterServicePromise!: Promise<ClusterForkServiceInterface>;
     
     constructor(public clusterMode: undefined | 'client' | 'server', private api: PluginAPI, private clusterWorkerId: string) {
     }
@@ -16,7 +16,7 @@ export class ClusterManagerImpl implements ClusterManager {
     }
 
     getClusterAddress(): string {
-        return process.env.SCRYPTED_CLUSTER_ADDRESS;
+        return process.env.SCRYPTED_CLUSTER_ADDRESS!;
     }
 
     getClusterMode(): 'server' | 'client' | undefined {

package/src/plugin/descriptor.ts

@@ -1,6 +1,6 @@
 import { ScryptedInterface, ScryptedInterfaceDescriptor, ScryptedInterfaceDescriptors } from "@scrypted/types";
 
-export const allInterfaceProperties: string[] = [].concat(...Object.values(ScryptedInterfaceDescriptors).map(type => type.properties));
+export const allInterfaceProperties: string[] = Object.values(ScryptedInterfaceDescriptors).map(type => type.properties).flat();
 
 export function getPropertyInterfaces(descriptors: { [scryptedInterface: string]: ScryptedInterfaceDescriptor }) {
     const propertyInterfaces: { [property: string]: ScryptedInterface } = {};
@@ -26,7 +26,7 @@ export function getInterfaceProperties(descriptors: { [scryptedInterface: string
 
 export function isValidInterfaceMethod(descriptors: { [scryptedInterface: string]: ScryptedInterfaceDescriptor }, interfaces: Set<string>, method: string) {
     const availableMethods = getInterfaceMethods(descriptors, interfaces);
-    return availableMethods.includes(method) || descriptors[ScryptedInterface.ScryptedDevice].methods.includes(method);
+    return availableMethods.includes(method) || descriptors[ScryptedInterface.ScryptedDevice]!.methods.includes(method);
 }
 
 export function isValidInterfaceProperty(descriptors: { [scryptedInterface: string]: ScryptedInterfaceDescriptor }, interfaces: string[], property: string): boolean {

package/src/plugin/device.ts

@@ -7,7 +7,7 @@ import { SystemManagerImpl } from './system';
 class DeviceLogger implements Logger {
     nativeId: ScryptedNativeId;
     api: PluginAPI;
-    logger: Promise<PluginLogger>;
+    logger!: Promise<PluginLogger>;
 
     constructor(api: PluginAPI, nativeId: ScryptedNativeId, public console: any) {
         this.api = api;
@@ -65,12 +65,12 @@ export class DeviceStateProxyHandler implements ProxyHandler<any> {
             return { id: this.id }
         if (p === 'setState')
             return this.setState;
-        return this.deviceManager.systemManager.state[this.id][p as string]?.value;
+        return this.deviceManager.systemManager.state[this.id]![p as string]?.value;
     }
 
     set?(target: any, p: PropertyKey, value: any, receiver: any) {
         checkProperty(p.toString(), value);
-        this.deviceManager.systemManager.state[this.id][p as string] = {
+        this.deviceManager.systemManager.state[this.id]![p as string] = {
             value,
         };
         this.setState(p.toString(), value);
@@ -84,10 +84,10 @@ interface DeviceManagerDevice {
 }
 
 export class DeviceManagerImpl implements DeviceManager {
-    api: PluginAPI;
-    nativeIds = new Map<string, DeviceManagerDevice>();
-    deviceStorage = new Map<string, StorageImpl>();
-    mixinStorage = new Map<string, Map<string, StorageImpl>>();
+    api!: PluginAPI;
+    nativeIds = new Map<ScryptedNativeId, DeviceManagerDevice>();
+    deviceStorage = new Map<ScryptedNativeId, StorageImpl>();
+    mixinStorage = new Map<ScryptedNativeId, Map<string, StorageImpl>>();
 
     constructor(public systemManager: SystemManagerImpl,
         public getDeviceConsole: (nativeId?: ScryptedNativeId) => Console,
@@ -103,7 +103,7 @@ export class DeviceManagerImpl implements DeviceManager {
     }
 
     getDeviceState(nativeId?: any): DeviceState {
-        const handler = new DeviceStateProxyHandler(this, this.nativeIds.get(nativeId).id,
+        const handler = new DeviceStateProxyHandler(this, this.nativeIds.get(nativeId)!.id,
             (property, value) => this.api.setState(nativeId, property, value));
         return new Proxy(handler, handler);
     }
@@ -136,7 +136,7 @@ export class DeviceManagerImpl implements DeviceManager {
     }
     pruneMixinStorage() {
         for (const nativeId of this.nativeIds.keys()) {
-            const storage = this.nativeIds.get(nativeId).storage;
+            const storage = this.nativeIds.get(nativeId)!.storage;
             for (const key of Object.keys(storage)) {
                 if (!key.startsWith('mixin:'))
                     continue;
@@ -152,7 +152,7 @@ export class DeviceManagerImpl implements DeviceManager {
     async onMixinEvent(id: string, nativeId: ScryptedNativeId, eventInterface: string, eventData: any) {
         return this.api.onMixinEvent(id, nativeId, eventInterface, eventData);
     }
-    getNativeIds(): string[] {
+    getNativeIds(): ScryptedNativeId[] {
         return Array.from(this.nativeIds.keys());
     }
     async onDeviceDiscovered(device: Device) {
@@ -219,20 +219,20 @@ export class StorageImpl implements Storage {
     }
 
     get storage(): { [key: string]: any } {
-        return this.deviceManager.nativeIds.get(this.nativeId).storage;
+        return this.deviceManager.nativeIds.get(this.nativeId)!.storage;
     }
 
     get length(): number {
-        return Object.keys(this.storage).filter(key => key.startsWith(this.prefix)).length;
+        return Object.keys(this.storage).filter(key => key.startsWith(this.prefix!)).length;
     }
 
     clear(): void {
         if (!this.prefix) {
-            this.deviceManager.nativeIds.get(this.nativeId).storage = {};
+            this.deviceManager.nativeIds.get(this.nativeId)!.storage = {};
         }
         else {
             const storage = this.storage;
-            Object.keys(this.storage).filter(key => key.startsWith(this.prefix)).forEach(key => delete storage[key]);
+            Object.keys(this.storage).filter(key => key.startsWith(this.prefix!)).forEach(key => delete storage[key]);
         }
         this.api.setStorage(this.nativeId, this.storage);
     }
@@ -242,9 +242,9 @@ export class StorageImpl implements Storage {
     }
     key(index: number): string {
         if (!this.prefix) {
-            return Object.keys(this.storage)[index];
+            return Object.keys(this.storage)[index]!;
         }
-        return Object.keys(this.storage).filter(key => key.startsWith(this.prefix))[index].substring(this.prefix.length);
+        return Object.keys(this.storage).filter(key => key.startsWith(this.prefix!))[index]!.substring(this.prefix!.length);
     }
     removeItem(key: string): void {
         delete this.storage[this.prefix + key];

package/src/plugin/endpoint.ts

@@ -3,10 +3,10 @@ import type { DeviceManagerImpl } from "./device";
 import type { PluginAPI } from "./plugin-api";
 
 export class EndpointManagerImpl implements EndpointManager {
-    deviceManager: DeviceManagerImpl;
-    api: PluginAPI;
-    pluginId: string;
-    mediaManager: MediaManager;
+    deviceManager!: DeviceManagerImpl;
+    api!: PluginAPI;
+    pluginId!: string;
+    mediaManager!: MediaManager;
 
     getEndpoint(nativeId?: ScryptedNativeId) {
         if (!nativeId)

package/src/plugin/media.ts

@@ -208,20 +208,25 @@ export abstract class MediaManagerBase implements MediaManager {
             .map(([id]) => {
                 const device = this.getDeviceById<MediaConverter & BufferConverter>(id);
 
-                return (device.converters || []).map(([fromMimeType, toMimeType], index) => {
-                    return {
-                        id: `${id}-${index}`,
-                        name: device.name,
-                        fromMimeType,
-                        toMimeType,
-                        convert(data, fromMimeType, toMimeType, options?) {
-                            // MediaConverter is injected the plugin's node runtime which may be compiled against an
-                            // older sdk that does not have MediaConverter. use the older convert method instead.
-                            // once BufferConverter is removed, this can be simplified to device.convertMedia.
-                            return (device.convertMedia || device.convert)(data, fromMimeType, toMimeType, options);
-                        },
-                    } as IdBufferConverter;
-                });
+                try {
+                    return (device.converters || []).map(([fromMimeType, toMimeType], index) => {
+                        return {
+                            id: `${id}-${index}`,
+                            name: device.name,
+                            fromMimeType,
+                            toMimeType,
+                            convert(data, fromMimeType, toMimeType, options?) {
+                                // MediaConverter is injected the plugin's node runtime which may be compiled against an
+                                // older sdk that does not have MediaConverter. use the older convert method instead.
+                                // once BufferConverter is removed, this can be simplified to device.convertMedia.
+                                return (device.convertMedia || device.convert)(data, fromMimeType, toMimeType, options);
+                            },
+                        } as IdBufferConverter;
+                    });
+                }
+                catch (e) {
+                    return [];
+                }
             });
 
         const converters = [...mediaConverters.flat(), ...bufferConverters];
@@ -343,7 +348,7 @@ export abstract class MediaManagerBase implements MediaManager {
                 fromMimeType: mediaObject.mimeType,
                 toMimeType,
                 convert: async (data, fromMimeType, toMimeType) => {
-                    return mediaObject.convert(toMimeType);
+                    return mediaObject.convert!(toMimeType);
                 }
             });
 
@@ -361,10 +366,10 @@ export abstract class MediaManagerBase implements MediaManager {
             // connect the intrinsic converter to other converters
             for (const candidate of converters) {
                 try {
-                    const candidateMime = new MimeType(candidate.fromMimeType);
+                    const candidateMime = new MimeType(candidate.fromMimeType!);
                     if (!mimeMatches(convertedMime, candidateMime))
                         continue;
-                    const outputWeight = parseFloat(candidateMime.parameters.get('converter-weight')) || (candidateMime.essence === '*/*' ? 1000 : 1);
+                    const outputWeight = parseFloat(candidateMime.parameters.get('converter-weight')!) || (candidateMime.essence === '*/*' ? 1000 : 1);
                     const candidateId = candidate.id;
                     node[candidateId] = outputWeight;
                 }
@@ -376,10 +381,10 @@ export abstract class MediaManagerBase implements MediaManager {
 
         for (const converter of converters) {
             try {
-                const inputMime = new MimeType(converter.fromMimeType);
-                const convertedMime = new MimeType(converter.toMimeType);
+                const inputMime = new MimeType(converter.fromMimeType!);
+                const convertedMime = new MimeType(converter.toMimeType!);
                 // catch all converters should be heavily weighted so as not to use them.
-                const inputWeight = parseFloat(inputMime.parameters.get('converter-weight')) || (inputMime.essence === '*/*' ? 1000 : 1);
+                const inputWeight = parseFloat(inputMime.parameters.get('converter-weight')!) || (inputMime.essence === '*/*' ? 1000 : 1);
                 // const convertedWeight = parseFloat(convertedMime.parameters.get('converter-weight')) || (convertedMime.essence === ScryptedMimeTypes.MediaObject ? 1000 : 1);
                 // const conversionWeight = inputWeight + convertedWeight;
                 const targetId = converter.id;
@@ -388,10 +393,10 @@ export abstract class MediaManagerBase implements MediaManager {
                 // edge matches
                 for (const candidate of converters) {
                     try {
-                        const candidateMime = new MimeType(candidate.fromMimeType);
+                        const candidateMime = new MimeType(candidate.fromMimeType!);
                         if (!mimeMatches(convertedMime, candidateMime))
                             continue;
-                        const outputWeight = parseFloat(candidateMime.parameters.get('converter-weight')) || (candidateMime.essence === '*/*' ? 1000 : 1);
+                        const outputWeight = parseFloat(candidateMime.parameters.get('converter-weight')!) || (candidateMime.essence === '*/*' ? 1000 : 1);
                         const candidateId = candidate.id;
                         node[candidateId] = inputWeight + outputWeight;
                     }
@@ -431,23 +436,23 @@ export abstract class MediaManagerBase implements MediaManager {
         let valueMime = new MimeType(mediaObject.mimeType);
 
         while (route.length) {
-            const node = route.shift();
-            const converter = converterMap.get(node);
-            const converterToMimeType = new MimeType(converter.toMimeType);
-            const converterFromMimeType = new MimeType(converter.fromMimeType);
+            const node = route.shift()!;
+            const converter = converterMap.get(node)!;
+            const converterToMimeType = new MimeType(converter.toMimeType!);
+            const converterFromMimeType = new MimeType(converter.fromMimeType!);
             const type = converterToMimeType.type === '*' ? valueMime.type : converterToMimeType.type;
             const subtype = converterToMimeType.subtype === '*' ? valueMime.subtype : converterToMimeType.subtype;
             let targetMimeType = `${type}/${subtype}`;
             if (!route.length && outputMime.parameters.size) {
                 const withParameters = new MimeType(targetMimeType);
                 for (const k of outputMime.parameters.keys()) {
-                    withParameters.parameters.set(k, outputMime.parameters.get(k));
+                    withParameters.parameters.set(k, outputMime.parameters.get(k)!);
                 }
                 targetMimeType = outputMime.toString();
             }
 
             if (converter.toMimeType === ScryptedMimeTypes.MediaObject) {
-                const mo = await converter.convert(value, valueMime.essence, toMimeType, { sourceId }) as MediaObjectInterface;
+                const mo = await converter.convert!(value, valueMime.essence, toMimeType, { sourceId }) as MediaObjectInterface;
                 const found = await this.convertMediaObject(mo, toMimeType);
                 return {
                     data: found,
@@ -455,7 +460,7 @@ export abstract class MediaManagerBase implements MediaManager {
                 };
             }
 
-            value = await converter.convert(value, valueMime.essence, targetMimeType, { sourceId }) as string | Buffer;
+            value = await converter.convert!(value, valueMime.essence, targetMimeType, { sourceId }) as string | Buffer;
             valueMime = new MimeType(targetMimeType);
         }
 

package/src/plugin/mediaobject.ts

@@ -5,12 +5,12 @@ import { MediaObjectRemote } from "./plugin-api";
 export class MediaObject implements MediaObjectRemote {
     __proxy_props: any;
 
-    constructor(public mimeType: string, public data: any, options: MediaObjectCreateOptions) {
+    constructor(public mimeType: string, public data: any, options?: MediaObjectCreateOptions) {
         this.__proxy_props = {}
         options ||= {};
         options.mimeType = mimeType;
-        options.convert ||= null;
-        options.toMimeTypes ||= null;
+        options!.convert ||= null!;
+        options!.toMimeTypes ||= null!;
 
         for (const [key, value] of Object.entries(options)) {
             if (RpcPeer.isTransportSafe(value))