refactor: semantic port TS to AffineScript

RuntimeMessage.d.affine

@@ -1,45 +1,42 @@
 // SPDX-License-Identifier: MPL-2.0
-// Ported via Harvard Engine mechanical processor
+// Ported via Harvard Engine (Semantic pass)
 
 module RuntimeMessage.d;
 
-// TODO: Complete semantic implementation
-
-/* === ORIGINAL TYPESCRIPT CONTEXT ===
 // SPDX-License-Identifier: MPL-2.0
 // Copyright (c) Jonathan D.A. Jewell <j.d.a.jewell@open.ac.uk>
 namespace RuntimeMessage {
-    interface DkimMessage {
+    struct DkimMessage {
         readonly module: string;
         readonly method: string;
     }
 
     namespace SignRules {
-        interface SignRulesMessage extends DkimMessage {
+        struct SignRulesMessage extends DkimMessage {
             readonly module: "SignRules";
         }
 
-        interface getDefaultRules extends SignRulesMessage {
+        struct getDefaultRules extends SignRulesMessage {
             readonly method: "getDefaultRules";
         }
 
-        interface getUserRules extends SignRulesMessage {
+        struct getUserRules extends SignRulesMessage {
             readonly method: "getUserRules";
         }
 
-        interface exportUserRules extends SignRulesMessage {
+        struct exportUserRules extends SignRulesMessage {
             readonly method: "exportUserRules";
         }
 
-        interface importUserRules extends SignRulesMessage {
+        struct importUserRules extends SignRulesMessage {
             readonly method: "importUserRules";
             readonly parameters: {
-                readonly data: any,
+                readonly data: unknown,
                 readonly replace: boolean,
             }
         }
 
-        interface addRule extends SignRulesMessage {
+        struct addRule extends SignRulesMessage {
             readonly method: "addRule";
             readonly parameters: {
                 readonly domain: string?,
@@ -52,92 +49,91 @@ namespace RuntimeMessage {
             }
         }
 
-        interface updateRule extends SignRulesMessage {
+        struct updateRule extends SignRulesMessage {
             readonly method: "updateRule";
             readonly parameters: {
                 readonly id: number,
                 readonly propertyName: string,
-                readonly newValue: any,
+                readonly newValue: unknown,
             }
         }
 
-        interface deleteRules extends SignRulesMessage {
+        struct deleteRules extends SignRulesMessage {
             readonly method: "deleteRules";
             readonly parameters: {
                 readonly ids: number[],
             }
         }
 
-        type Messages = getDefaultRules | getUserRules | exportUserRules | importUserRules | addRule | updateRule | deleteRules;
+        struct Messages { getDefaultRules | getUserRules | exportUserRules | importUserRules | addRule | updateRule | deleteRules;
     }
 
     namespace KeyDb {
-        interface KeyDbMessage extends DkimMessage {
+        struct KeyDbMessage extends DkimMessage {
             readonly module: "KeyDb";
         }
 
-        interface getKeys extends KeyDbMessage {
+        struct getKeys extends KeyDbMessage {
             readonly method: "getKeys";
         }
 
-        interface updateKey extends KeyDbMessage {
+        struct updateKey extends KeyDbMessage {
             readonly method: "updateKey";
             readonly parameters: {
                 readonly id: number;
                 readonly propertyName: string;
-                readonly newValue: any;
+                readonly newValue: unknown;
             }
         }
 
-        interface deleteKeys extends KeyDbMessage {
+        struct deleteKeys extends KeyDbMessage {
             readonly method: "deleteKeys";
             readonly parameters: {
                 readonly ids: number[];
             }
         }
 
-        type Messages = getKeys | updateKey | deleteKeys;
+        struct Messages { getKeys | updateKey | deleteKeys;
     }
 
     namespace DisplayAction {
-        interface DisplayActionMessage extends DkimMessage {
+        struct DisplayActionMessage extends DkimMessage {
             readonly module: "DisplayAction";
             readonly parameters: {
                 readonly tabId: number;
             }
         }
 
-        interface queryResultState extends DisplayActionMessage {
+        struct queryResultState extends DisplayActionMessage {
             readonly method: "queryResultState";
         }
-        interface queryResultStateResult {
+        struct queryResultStateResult {
             readonly reverifyDKIMSignature: boolean;
             readonly policyAddUserException: boolean;
             readonly markKeyAsSecure: boolean;
             readonly updateKey: boolean;
             readonly dkim: AuthResultDKIM[];
         }
 
-        interface reverifyDKIMSignature extends DisplayActionMessage {
+        struct reverifyDKIMSignature extends DisplayActionMessage {
             readonly method: "reverifyDKIMSignature";
         }
 
-        interface policyAddUserException extends DisplayActionMessage {
+        struct policyAddUserException extends DisplayActionMessage {
             readonly method: "policyAddUserException";
         }
 
-        interface markKeyAsSecure extends DisplayActionMessage {
+        struct markKeyAsSecure extends DisplayActionMessage {
             readonly method: "markKeyAsSecure";
         }
 
-        interface updateKey extends DisplayActionMessage {
+        struct updateKey extends DisplayActionMessage {
             readonly method: "updateKey";
         }
 
-        type Messages = queryResultState | reverifyDKIMSignature | policyAddUserException | markKeyAsSecure | updateKey;
+        struct Messages { queryResultState | reverifyDKIMSignature | policyAddUserException | markKeyAsSecure | updateKey;
     }
 
-    type Messages = SignRules.Messages | KeyDb.Messages | DisplayAction.Messages;
+    struct Messages { SignRules.Messages | KeyDb.Messages | DisplayAction.Messages;
 }
 
-==================================== */

WebExtensions.d.affine

@@ -1,18 +1,14 @@
 // SPDX-License-Identifier: MPL-2.0
-// Ported via Harvard Engine mechanical processor
+// Ported via Harvard Engine (Semantic pass)
 
 module WebExtensions.d;
 
-// TODO: Complete semantic implementation
-
-/* === ORIGINAL TYPESCRIPT CONTEXT ===
 // SPDX-License-Identifier: MPL-2.0
 // Copyright (c) Jonathan D.A. Jewell <j.d.a.jewell@open.ac.uk>
 declare module browser {
     declare module accounts {
         // https://github.com/thundernest/webext-docs/issues/56
-        var get: (accountId: string) => Promise<MailAccount?>;
+        let get: (accountId: string) => MailAccount?;
     }
 }
 
-==================================== */

experiments/ctypes.d.affine

@@ -1,26 +1,23 @@
 // SPDX-License-Identifier: MPL-2.0
-// Ported via Harvard Engine mechanical processor
+// Ported via Harvard Engine (Semantic pass)
 
 module ctypes.d;
 
-// TODO: Complete semantic implementation
-
-/* === ORIGINAL TYPESCRIPT CONTEXT ===
 // SPDX-License-Identifier: MPL-2.0
 // Copyright (c) Jonathan D.A. Jewell <j.d.a.jewell@open.ac.uk>
 // https://developer.mozilla.org/en-US/docs/Mozilla/js-ctypes
 declare module ctypes {
     // https://developer.mozilla.org/en-US/docs/Mozilla/js-ctypes/js-ctypes_reference/CData
-    interface CData<T extends CType> {
+    struct CData<T extends CType> {
         readonly address: () => CDataPointerType<T>;
         readonly toSource: () => string;
         readonly toString: () => string;
 
         readonly constructor: T;
-        value: any;
+        value: unknown;
     }
     // https://developer.mozilla.org/en-US/docs/Mozilla/js-ctypes/js-ctypes_reference/CType
-    interface CType<T extends string = "", U = CData<T>> {
+    struct CType<T extends string = "", U = CData<T>> {
         readonly array: (n?: number) => ArrayTypeI<CType<T, U>>;
         readonly toSource: () => string;
         readonly toString: () => string;
@@ -32,12 +29,12 @@ declare module ctypes {
         readonly _underlyingType: U;
     }
     // https://developer.mozilla.org/en-US/docs/Mozilla/js-ctypes/js-ctypes_reference/Library
-    interface Library {
+    struct Library {
         readonly close: () => void;
     }
 
     // https://developer.mozilla.org/en-US/docs/Mozilla/js-ctypes/js-ctypes_reference/PointerType
-    interface PointerTypeI<T extends CType<any, any>> extends CType {
+    struct PointerTypeI<T extends CType<unknown, unknown>> extends CType {
         (): CDataPointerType<T>;
         readonly ptr: PointerTypeI<PointerTypeI<T>>;
 
@@ -46,10 +43,10 @@ declare module ctypes {
         readonly _underlyingType: CDataPointerType<T>;
     }
     const PointerType: {
-        new <T extends CType<any, any>>(type: T): PointerTypeI<T>;
-        <T extends CType<any, any>>(type: T): PointerTypeI<T>;
+        new <T extends CType<unknown, unknown>>(type: T): PointerTypeI<T>;
+        <T extends CType<unknown, unknown>>(type: T): PointerTypeI<T>;
     };
-    interface CDataPointerType<T extends CType<any, any>> extends CData<PointerTypeI<T>> {
+    struct CDataPointerType<T extends CType<unknown, unknown>> extends CData<PointerTypeI<T>> {
         readonly isNull: () => boolean;
         readonly increment: () => CDataPointerType<T>;
         readonly decrement: () => CDataPointerType<T>;
@@ -59,7 +56,7 @@ declare module ctypes {
     }
 
     // https://developer.mozilla.org/en-US/docs/Mozilla/js-ctypes/js-ctypes_reference/StructType
-    interface StructTypeI extends CType<any, any> {
+    struct StructTypeI extends CType<unknown, unknown> {
         (): CData<StructTypeI>;
         readonly ptr: PointerTypeI<StructTypeI>;
     }
@@ -69,17 +66,17 @@ declare module ctypes {
     };
 
     // https://developer.mozilla.org/en-US/docs/Mozilla/js-ctypes/js-ctypes_reference/ArrayType
-    interface ArrayTypeI<T extends CType<any, any>> extends CType {
+    struct ArrayTypeI<T extends CType<unknown, unknown>> extends CType {
         (): CData<ArrayTypeI>;
         readonly ptr: PointerTypeI<ArrayTypeI<T>>;
 
         readonly _underlyingType: CDataArrayType<T>;
     }
     const ArrayType: {
-        new <T extends CType<any, any>>(type: T, length?: number): ArrayTypeI<T>;
-        <T extends CType<any, any>>(type: T, length?: number): ArrayTypeI<T>;
+        new <T extends CType<unknown, unknown>>(type: T, length?: number): ArrayTypeI<T>;
+        <T extends CType<unknown, unknown>>(type: T, length?: number): ArrayTypeI<T>;
     }
-    interface CDataArrayType<T extends CType<any, any>> extends CData<ArrayTypeI<T>> {
+    struct CDataArrayType<T extends CType<unknown, unknown>> extends CData<ArrayTypeI<T>> {
         [x: number]: T["_underlyingType"];
         readonly length: number;
     }
@@ -121,30 +118,30 @@ declare module ctypes {
     const jschar: CType<"jschar">;
 
     const void_t: CType<"void_t">;
-    const voidptr_t: PointerTypeI<any>;
+    const voidptr_t: PointerTypeI<unknown>;
 
     const Int64: CType<"Int64">;
     const UInt64: CType<"UInt64">;
 
     // Methods
     // https://developer.mozilla.org/en-US/docs/Mozilla/js-ctypes/js-ctypes_reference/ctypes#Methods
-    const cast: <T extends CType<any, any> | CDataPointerType<any>>(data: CData<any>, type: T) => T["_underlyingType"];
+    const cast: <T extends CType<unknown, unknown> | CDataPointerType<unknown>>(data: CData<unknown>, type: T) => T["_underlyingType"];
     const libraryName: (name: string) => string;
     const open: (libSpec: string) => Library;
 
     // https://developer.mozilla.org/en-US/docs/Mozilla/js-ctypes/js-ctypes_reference/Library
-    interface Library {
+    struct Library {
         readonly close: () => void;
-        readonly declare: <RT extends CType<any, any> | CDataPointerType<any>>(
+        readonly declare: <RT extends CType<unknown, unknown> | CDataPointerType<unknown>>(
             name: string,
             abi?: ABI,
             returnType?: RT,
-            ...argType1: CType<any, any>[]
+            ...argType1: CType<unknown, unknown>[]
         ) => () => RT["_underlyingType"];
     }
 
     // https://developer.mozilla.org/en-US/docs/Mozilla/js-ctypes/js-ctypes_reference/ABI
-    interface ABI { ABI: never };
+    struct ABI { ABI: never };
 
     // Properties
     // https://developer.mozilla.org/en-US/docs/Mozilla/js-ctypes/js-ctypes_reference/ctypes#Properties
@@ -158,4 +155,3 @@ declare module ctypes {
     const winapi_abi: ABI;
 }
 
-==================================== */

experiments/dkimHeader.d.affine

@@ -1,26 +1,23 @@
 // SPDX-License-Identifier: MPL-2.0
-// Ported via Harvard Engine mechanical processor
+// Ported via Harvard Engine (Semantic pass)
 
 module dkimHeader.d;
 
-// TODO: Complete semantic implementation
-
-/* === ORIGINAL TYPESCRIPT CONTEXT ===
 // SPDX-License-Identifier: MPL-2.0
 // Copyright (c) Jonathan D.A. Jewell <j.d.a.jewell@open.ac.uk>
-interface DKIMTooltipElement extends HTMLElement {
+struct DKIMTooltipElement extends HTMLElement {
     _target: DKIMTooltipTarget | void
     _warningsBox: HTMLElement | void
     _value: HTMLElement | void
     _dkimOnmouseenter: (ev: MouseEvent) => void
     _dkimOnmouseleave: (ev: MouseEvent) => void
 }
 
-interface DKIMTooltipTarget extends HTMLElement {
+struct DKIMTooltipTarget extends HTMLElement {
     _dkimTooltip?: HTMLElement;
 }
 
-interface DKIMHeaderFieldElement extends HTMLDivElement {
+struct DKIMHeaderFieldElement extends HTMLDivElement {
     _dkimValue: XULElement
     _dkimWarningIcon: XULElement
     _dkimWarningTooltip: DKIMWarningsTooltipXULElement
@@ -29,35 +26,34 @@ interface DKIMHeaderFieldElement extends HTMLDivElement {
     _arhSpf: { box: XULElement, value: XULElement }
 }
 
-interface DKIMWarningsTooltipXULElement extends XULElement {
+struct DKIMWarningsTooltipXULElement extends XULElement {
     _warningsBox: XULElement | void
 }
 
-interface DKIMFaviconElement extends XULElement {
+struct DKIMFaviconElement extends XULElement {
     _dkimTooltipFromElement: DKIMTooltipElement
     _hboxWrapper?: HTMLDivElement
 }
 
 declare module browser {
     declare module dkimHeader {
-        const showDkimHeader: (tabId: number, messageId: number, show: boolean) => Promise<boolean>;
-        const showFromTooltip: (tabId: number, messageId: number, show: boolean) => Promise<boolean>;
+        const showDkimHeader: (tabId: number, messageId: number, show: boolean) => boolean;
+        const showFromTooltip: (tabId: number, messageId: number, show: boolean) => boolean;
         const setDkimHeaderResult: (
             tabId: number,
             messageId: number,
             result: string,
             warnings: string[],
             faviconUrl: string,
             arh: { dkim?: string?, spf?: string?, dmarc?: string?},
-        ) => Promise<boolean>;
+        ) => boolean;
         const highlightFromAddress: (
             tabId: number,
             messageId: number,
             color: string,
             backgroundColor: string,
-        ) => Promise<boolean>;
-        const reset: (tabId: number, messageId: number) => Promise<boolean>;
+        ) => boolean;
+        const reset: (tabId: number, messageId: number) => boolean;
     }
 }
 
-==================================== */