npm - @oneuptime/common - Versions diffs - 13.0.6 → 13.0.7 - Mend

@oneuptime/common 13.0.6 → 13.0.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (589) hide show

package/Tests/Server/Utils/VendorAssets.test.ts CHANGED Viewed

@@ -45,7 +45,14 @@ interface AssetResponse {
 const INDEX_PAGE: string = "<html>index</html>";
-const REPOSITORY_ROOT: string = path.resolve(__dirname, "..", "..", "..", "..");
+const REPOSITORY_ROOT: string = path.resolve(
+  __dirname,
+  "..",
+  "..",
+  "..",
+  "..",
+  "..",
+);
 describe("vendored browser assets", () => {
   let server: Server;
@@ -167,7 +174,7 @@ describe("vendored browser assets", () => {
         .trim();
       expect(tracked.split("\n").filter(Boolean)).toEqual([
-        "Common/Server/Static/Vendor/tailwind/tailwind-3.4.5.js",
+        "packages/Common/Server/Static/Vendor/tailwind/tailwind-3.4.5.js",
       ]);
     });
   });
@@ -201,7 +208,12 @@ describe("vendored browser assets", () => {
     test("writes it to the path each index.ejs asks for", () => {
       expect(esbuildConfig).toContain('"assets/js"');
-      const appRoot: string = path.join(REPOSITORY_ROOT, "App", "FeatureSet");
+      const appRoot: string = path.join(
+        REPOSITORY_ROOT,
+        "packages",
+        "App",
+        "FeatureSet",
+      );
       for (const [service, routePrefix] of [
         ["Dashboard", "dashboard"],
@@ -372,6 +384,7 @@ describe("vendored browser assets", () => {
       const copies: Array<string> = [
         path.join(
           REPOSITORY_ROOT,
+          "packages",
           "Common",
           "UI",
           "Images",
@@ -381,6 +394,7 @@ describe("vendored browser assets", () => {
         ),
         path.join(
           REPOSITORY_ROOT,
+          "packages",
           "Home",
           "Static",
           "img",

package/Tests/Types/AI/AIChatPageContext.test.ts CHANGED Viewed

Binary file

package/Tests/Types/AI/AIResourceContext.test.ts ADDED Viewed

@@ -0,0 +1,312 @@
+import AIChatPageContextType, {
+  AIChatPageContext,
+  AIChatPageContextHelper,
+} from "../../../Types/AI/AIChatPageContext";
+import {
+  AIResourceSubresourceKind,
+  AIResourceType,
+  getAIResourceDefinition,
+  isAIResourceType,
+} from "../../../Types/AI/AIResourceContext";
+import { JSONObject } from "../../../Types/JSON";
+import ServiceType from "../../../Types/Telemetry/ServiceType";
+import { describe, expect, test } from "@jest/globals";
+const RESOURCE_ID: string = "11111111-1111-4111-8111-111111111111";
+function resource(overrides: JSONObject = {}): JSONObject {
+  return {
+    type: AIChatPageContextType.Resource,
+    resourceType: AIResourceType.KubernetesCluster,
+    entityId: RESOURCE_ID,
+    ...overrides,
+  };
+}
+describe("infrastructure resource context validation", () => {
+  test.each(Object.values(AIResourceType))(
+    "%s detail requires a parent UUID and strips arbitrary client data",
+    (resourceType: AIResourceType) => {
+      expect(
+        AIChatPageContextHelper.sanitize(
+          resource({
+            resourceType,
+            entityTitle: "Production\n cluster",
+            projectId: "another-project",
+            credentials: { password: "never-forward" },
+            filters: { arbitrary: "never-forward" },
+          }),
+        ),
+      ).toEqual({
+        type: AIChatPageContextType.Resource,
+        resourceType,
+        entityId: RESOURCE_ID,
+        entityTitle: "Production cluster",
+      });
+      expect(
+        AIChatPageContextHelper.sanitize(
+          resource({ resourceType, entityId: "settings" }),
+        ),
+      ).toBeUndefined();
+    },
+  );
+  test.each(Object.values(AIResourceType))(
+    "%s list retains its kind without carrying a selected entity",
+    (resourceType: AIResourceType) => {
+      expect(
+        AIChatPageContextHelper.sanitize({
+          type: AIChatPageContextType.ResourcesList,
+          resourceType,
+          entityId: RESOURCE_ID,
+          entityTitle: "ignored",
+          subresource: { kind: "Pod", key: "ignored" },
+        }),
+      ).toEqual({ type: AIChatPageContextType.ResourcesList, resourceType });
+    },
+  );
+  test.each([
+    undefined,
+    null,
+    "",
+    "kubernetes",
+    "Unknown",
+    "__proto__",
+    123,
+    {},
+  ])("rejects missing or invalid resource kind %p", (resourceType: unknown) => {
+    expect(isAIResourceType(resourceType)).toBe(false);
+    expect(
+      AIChatPageContextHelper.sanitize(
+        resource({ resourceType } as JSONObject),
+      ),
+    ).toBeUndefined();
+  });
+  test("IoT fleet telemetry keeps its historical discriminator", () => {
+    expect(getAIResourceDefinition(AIResourceType.IoTFleet)).toEqual(
+      expect.objectContaining({
+        type: AIResourceType.IoTFleet,
+        serviceType: ServiceType.IoTDevice,
+        facetKey: "iotFleetId",
+      }),
+    );
+  });
+  test.each([
+    [AIResourceType.Host, AIResourceSubresourceKind.Process, "1234"],
+    [
+      AIResourceType.DockerHost,
+      AIResourceSubresourceKind.Container,
+      "checkout",
+    ],
+    [
+      AIResourceType.PodmanHost,
+      AIResourceSubresourceKind.Container,
+      "checkout",
+    ],
+    [
+      AIResourceType.KubernetesCluster,
+      AIResourceSubresourceKind.Pod,
+      "checkout-7c87",
+    ],
+    [
+      AIResourceType.DockerSwarmCluster,
+      AIResourceSubresourceKind.Task,
+      "task-a123",
+    ],
+    [
+      AIResourceType.ProxmoxCluster,
+      AIResourceSubresourceKind.Guest,
+      "qemu/100",
+    ],
+    [
+      AIResourceType.VMwareVCenter,
+      AIResourceSubresourceKind.VirtualMachine,
+      "vm-23",
+    ],
+    [AIResourceType.CephCluster, AIResourceSubresourceKind.Osd, "osd.3"],
+    [
+      AIResourceType.ServerlessFunction,
+      AIResourceSubresourceKind.Instance,
+      "instance-2",
+    ],
+    [
+      AIResourceType.CloudResource,
+      AIResourceSubresourceKind.Instance,
+      "i-0123",
+    ],
+    [AIResourceType.IoTFleet, AIResourceSubresourceKind.Device, "device/123"],
+    [AIResourceType.NetworkDevice, AIResourceSubresourceKind.Interface, "eth0"],
+  ] as Array<[AIResourceType, AIResourceSubresourceKind, string]>)(
+    "%s child %s preserves its external identity separately from the parent UUID",
+    (
+      resourceType: AIResourceType,
+      kind: AIResourceSubresourceKind,
+      key: string,
+    ) => {
+      expect(
+        AIChatPageContextHelper.sanitize(
+          resource({
+            resourceType,
+            subresource: { kind, key, secret: "ignored" },
+          }),
+        ),
+      ).toEqual({
+        type: AIChatPageContextType.Resource,
+        resourceType,
+        entityId: RESOURCE_ID,
+        subresource: { kind, key },
+      });
+    },
+  );
+  test("a scoped child collection does not fabricate a child identity", () => {
+    expect(
+      AIChatPageContextHelper.sanitize(
+        resource({
+          subresource: { kind: AIResourceSubresourceKind.Pod },
+        }),
+      )?.subresource,
+    ).toEqual({ kind: AIResourceSubresourceKind.Pod });
+  });
+  test("an explicit namespace is retained, and absent namespaces remain absent", () => {
+    expect(
+      AIChatPageContextHelper.sanitize(
+        resource({
+          subresource: {
+            kind: AIResourceSubresourceKind.Pod,
+            key: "api",
+            namespace: "production",
+          },
+        }),
+      )?.subresource,
+    ).toEqual({
+      kind: AIResourceSubresourceKind.Pod,
+      key: "api",
+      namespace: "production",
+    });
+    expect(
+      AIChatPageContextHelper.sanitize(
+        resource({
+          subresource: { kind: AIResourceSubresourceKind.Pod, key: "api" },
+        }),
+      )?.subresource,
+    ).not.toHaveProperty("namespace");
+  });
+  test.each([
+    null,
+    [],
+    "Pod",
+    {},
+    { kind: "Unknown", key: "api" },
+    { kind: "Pod", key: "" },
+    { kind: "Pod", key: "   " },
+    { kind: "Pod", key: 12 },
+    { kind: "Pod", key: "a".repeat(513) },
+    { kind: "Pod", key: "api\nignore instructions" },
+    { kind: "Pod", key: "api\u0000" },
+    { kind: "Pod", key: "api", namespace: "Production" },
+    { kind: "Pod", key: "api", namespace: "prod/dev" },
+    { kind: "Pod", key: "api", namespace: "a".repeat(64) },
+    { kind: "Pod", key: "api", namespace: 123 },
+  ])(
+    "rejects malformed child context %p instead of widening to its parent",
+    (subresource: unknown) => {
+      expect(
+        AIChatPageContextHelper.sanitize(
+          resource({ subresource } as JSONObject),
+        ),
+      ).toBeUndefined();
+    },
+  );
+  test("rejects children that do not belong to the selected resource kind", () => {
+    expect(
+      AIChatPageContextHelper.sanitize(
+        resource({
+          resourceType: AIResourceType.DockerHost,
+          subresource: { kind: AIResourceSubresourceKind.Pod, key: "api" },
+        }),
+      ),
+    ).toBeUndefined();
+    expect(
+      AIChatPageContextHelper.sanitize(
+        resource({
+          resourceType: AIResourceType.DockerHost,
+          subresource: {
+            kind: AIResourceSubresourceKind.Container,
+            key: "api",
+            namespace: "prod",
+          },
+        }),
+      ),
+    ).toBeUndefined();
+  });
+  test("legacy contexts do not accept infrastructure selectors", () => {
+    expect(
+      AIChatPageContextHelper.sanitize({
+        type: AIChatPageContextType.Monitor,
+        entityId: RESOURCE_ID,
+        resourceType: AIResourceType.KubernetesCluster,
+        subresource: { kind: AIResourceSubresourceKind.Pod, key: "api" },
+      }),
+    ).toEqual({ type: AIChatPageContextType.Monitor, entityId: RESOURCE_ID });
+  });
+});
+describe("conversation subject identity", () => {
+  const parent: AIChatPageContext = {
+    type: AIChatPageContextType.Resource,
+    resourceType: AIResourceType.KubernetesCluster,
+    entityId: RESOURCE_ID,
+    entityTitle: "Production",
+  };
+  test("renaming the presentation title does not change the subject", () => {
+    expect(AIChatPageContextHelper.getIdentity(parent)).toBe(
+      AIChatPageContextHelper.getIdentity({
+        ...parent,
+        entityTitle: "Renamed",
+      }),
+    );
+  });
+  test("switching resource kind with the same UUID changes the subject", () => {
+    expect(AIChatPageContextHelper.getIdentity(parent)).not.toBe(
+      AIChatPageContextHelper.getIdentity({
+        ...parent,
+        resourceType: AIResourceType.DockerHost,
+      }),
+    );
+  });
+  test("child and namespace changes cannot reuse the previous subject", () => {
+    const pod: AIChatPageContext = {
+      ...parent,
+      subresource: {
+        kind: AIResourceSubresourceKind.Pod,
+        key: "api",
+        namespace: "prod",
+      },
+    };
+    for (const child of [
+      undefined,
+      { kind: AIResourceSubresourceKind.Pod, key: "worker", namespace: "prod" },
+      { kind: AIResourceSubresourceKind.Pod, key: "api", namespace: "dev" },
+      {
+        kind: AIResourceSubresourceKind.Deployment,
+        key: "api",
+        namespace: "prod",
+      },
+    ]) {
+      expect(AIChatPageContextHelper.getIdentity(pod)).not.toBe(
+        AIChatPageContextHelper.getIdentity({ ...parent, subresource: child }),
+      );
+    }
+  });
+});

package/Tests/Types/Database/UniqueColumnsTogether.test.ts ADDED Viewed

@@ -0,0 +1,100 @@
+import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import UniqueColumnsTogether, {
+  UniqueColumnsTogetherMetadata,
+} from "../../../Types/Database/UniqueColumnsTogether";
+import { describe, expect, test } from "@jest/globals";
+/*
+ * @UniqueColumnsTogether is read off the model PROTOTYPE by
+ * DatabaseService.create (see issue #3394), so the ways a prototype value can
+ * go wrong are the ways this can: a second decorator overwriting the first, a
+ * subclass writing into its parent's list, or a caller's array being mutated
+ * after the fact.
+ */
+describe("UniqueColumnsTogether", () => {
+  test("a model without it declares no constraint", () => {
+    class Plain extends BaseModel {}
+    expect(new Plain().getUniqueColumnsTogether()).toEqual([]);
+  });
+  test("records the columns and the message", () => {
+    @UniqueColumnsTogether(
+      ["incidentId", "teamId", "projectId"],
+      "This team is already an owner of this incident.",
+    )
+    class Owner extends BaseModel {}
+    expect(new Owner().getUniqueColumnsTogether()).toEqual([
+      {
+        columnNames: ["incidentId", "teamId", "projectId"],
+        errorMessage: "This team is already an owner of this incident.",
+      },
+    ]);
+  });
+  test("is stackable - a second declaration does not replace the first", () => {
+    @UniqueColumnsTogether(["projectId", "name"], "Name is taken.")
+    @UniqueColumnsTogether(["projectId", "slug"], "Slug is taken.")
+    class Twice extends BaseModel {}
+    const constraints: Array<UniqueColumnsTogetherMetadata> =
+      new Twice().getUniqueColumnsTogether();
+    expect(constraints).toHaveLength(2);
+    expect(
+      constraints.map((c: UniqueColumnsTogetherMetadata) => {
+        return c.errorMessage;
+      }),
+    ).toEqual(expect.arrayContaining(["Name is taken.", "Slug is taken."]));
+  });
+  test("a subclass adds to its own list and leaves the parent's alone", () => {
+    @UniqueColumnsTogether(["projectId", "name"], "Name is taken.")
+    class Parent extends BaseModel {}
+    @UniqueColumnsTogether(["projectId", "slug"], "Slug is taken.")
+    class Child extends Parent {}
+    expect(new Parent().getUniqueColumnsTogether()).toEqual([
+      { columnNames: ["projectId", "name"], errorMessage: "Name is taken." },
+    ]);
+    expect(new Child().getUniqueColumnsTogether()).toEqual([
+      { columnNames: ["projectId", "slug"], errorMessage: "Slug is taken." },
+    ]);
+  });
+  test("an undecorated subclass inherits its parent's constraint", () => {
+    @UniqueColumnsTogether(["projectId", "name"], "Name is taken.")
+    class Parent extends BaseModel {}
+    class Child extends Parent {}
+    expect(new Child().getUniqueColumnsTogether()).toHaveLength(1);
+  });
+  test("keeps its own copy of the column list", () => {
+    const columns: Array<string> = ["projectId", "name"];
+    @UniqueColumnsTogether(columns, "Name is taken.")
+    class Owner extends BaseModel {}
+    columns.push("somethingElse");
+    expect(new Owner().getUniqueColumnsTogether()[0]!.columnNames).toEqual([
+      "projectId",
+      "name",
+    ]);
+  });
+  test("is not an own property, so it never ends up in a serialized row", () => {
+    @UniqueColumnsTogether(["projectId", "name"], "Name is taken.")
+    class Owner extends BaseModel {}
+    const model: Owner = new Owner();
+    expect(Object.keys(model)).not.toContain("uniqueColumnsTogether");
+    expect(JSON.stringify(model)).not.toContain("Name is taken.");
+  });
+});

package/Tests/Types/Monitor/MetricAndProfileDefaultCriteria.test.ts CHANGED Viewed

@@ -651,7 +651,7 @@ describe("Default criteria for metric-backed and profile monitors", () => {
         });
         expect(result).toBeTruthy();
-        expect(result).toContain("greater than");
+        expect(result).toContain("above the 0 threshold");
       },
     );
@@ -676,7 +676,7 @@ describe("Default criteria for metric-backed and profile monitors", () => {
         });
         expect(result).toBeTruthy();
-        expect(result).toContain("equal to 0");
+        expect(result).toContain("equal to the 0 threshold");
       },
     );
@@ -744,7 +744,7 @@ describe("Default criteria for metric-backed and profile monitors", () => {
       expect(result).toBeTruthy();
       expect(result).toContain("Profile Count");
-      expect(result).toContain("greater than");
+      expect(result).toContain("above the 0 threshold");
     });
     test("Profiles online criteria does not match when none arrived", async () => {
@@ -764,7 +764,7 @@ describe("Default criteria for metric-backed and profile monitors", () => {
       expect(result).toBeTruthy();
       expect(result).toContain("Profile Count");
-      expect(result).toContain("equal to 0");
+      expect(result).toContain("equal to the 0 threshold");
     });
     test("Profiles offline criteria does not match when profiles arrived", async () => {

package/Tests/Types/Monitor/MonitorStepRetryPersistence.test.ts ADDED Viewed

@@ -0,0 +1,125 @@
+import HTTPMethod from "../../../Types/API/HTTPMethod";
+import { JSONArray, JSONObject, ObjectType } from "../../../Types/JSON";
+import JSONFunctions from "../../../Types/JSONFunctions";
+import MonitorCriteria from "../../../Types/Monitor/MonitorCriteria";
+import MonitorStep from "../../../Types/Monitor/MonitorStep";
+import MonitorSteps from "../../../Types/Monitor/MonitorSteps";
+function apiPayload(retryCounts: Array<number | null | undefined>): JSONObject {
+  return {
+    _type: ObjectType.MonitorSteps,
+    value: {
+      defaultMonitorStatusId: "11111111-1111-4111-8111-111111111111",
+      monitorStepsInstanceArray: retryCounts.map(
+        (retryCount: number | null | undefined): JSONObject => {
+          return {
+            _type: ObjectType.MonitorStep,
+            value: {
+              id: "22222222-2222-4222-8222-222222222222",
+              monitorDestination: {
+                _type: ObjectType.URL,
+                value: "https://example.com/health",
+              },
+              monitorCriteria: new MonitorCriteria().toJSON(),
+              requestType: HTTPMethod.GET,
+              allowSelfSignedCertificates: true,
+              ...(retryCount === undefined ? {} : { retryCount }),
+            },
+          };
+        },
+      ),
+    },
+  };
+}
+function stepValues(payload: JSONObject): Array<JSONObject> {
+  return (
+    (payload["value"] as JSONObject)["monitorStepsInstanceArray"] as JSONArray
+  ).map((step: JSONObject): JSONObject => {
+    return step["value"] as JSONObject;
+  });
+}
+function databaseRoundTrip(steps: MonitorSteps): MonitorSteps {
+  // Exercise the same transformer used for the Monitor's JSON database column.
+  const persisted: JSONObject = MonitorSteps.getDatabaseTransformer().to(steps);
+  return MonitorSteps.getDatabaseTransformer().from(
+    JSON.parse(JSON.stringify(persisted)),
+  ) as MonitorSteps;
+}
+describe("API monitor retry settings across persistence", () => {
+  test.each([undefined, null, 0, 1, 2, 3])(
+    "preserves retryCount %s through API decoding, database storage, and GET serialization",
+    (retryCount: number | null | undefined): void => {
+      const payload: JSONObject = apiPayload([retryCount]);
+      const originalPayload: string = JSON.stringify(payload);
+      const expected: number | undefined = retryCount ?? undefined;
+      const decoded: MonitorSteps = JSONFunctions.deserialize({
+        monitorSteps: payload,
+      })["monitorSteps"] as MonitorSteps;
+      expect(decoded).toBeInstanceOf(MonitorSteps);
+      expect(decoded.data!.monitorStepsInstanceArray[0]!.data!.retryCount).toBe(
+        expected,
+      );
+      const stored: MonitorSteps = databaseRoundTrip(decoded);
+      const cloned: MonitorSteps = MonitorSteps.clone(stored);
+      const response: JSONObject = JSON.parse(JSON.stringify(cloned.toJSON()));
+      const value: JSONObject = stepValues(response)[0]!;
+      expect(value["retryCount"]).toBe(expected);
+      if (expected === undefined) {
+        // Missing is inherited from the probe, not an explicit choice of 3.
+        expect(value).not.toHaveProperty("retryCount");
+      } else {
+        expect(value).toHaveProperty("retryCount", expected);
+      }
+      expect(value["requestType"]).toBe(HTTPMethod.GET);
+      expect(value["allowSelfSignedCertificates"]).toBe(true);
+      expect(JSON.stringify(payload)).toBe(originalPayload);
+    },
+  );
+  test("an unrelated criteria edit does not turn an inherited retry count into an override", (): void => {
+    const steps: MonitorSteps = MonitorSteps.fromJSON(apiPayload([undefined]));
+    const edited: MonitorSteps = MonitorSteps.clone(databaseRoundTrip(steps));
+    edited.data!.monitorStepsInstanceArray[0]!.setRequestType(HTTPMethod.POST);
+    const saved: MonitorSteps = databaseRoundTrip(edited);
+    expect(stepValues(saved.toJSON())[0]).not.toHaveProperty("retryCount");
+    expect(saved.data!.monitorStepsInstanceArray[0]!.data!.requestType).toBe(
+      HTTPMethod.POST,
+    );
+  });
+  test.each([0, 1, 2, 3])(
+    "an explicit edit to %s is stored and clearing it restores inheritance",
+    (retryCount: number): void => {
+      const steps: MonitorSteps = MonitorSteps.fromJSON(
+        apiPayload([undefined]),
+      );
+      steps.data!.monitorStepsInstanceArray[0]!.setRetryCount(retryCount);
+      const saved: MonitorSteps = databaseRoundTrip(steps);
+      expect(stepValues(saved.toJSON())[0]!["retryCount"]).toBe(retryCount);
+      saved.data!.monitorStepsInstanceArray[0]!.setRetryCount(undefined);
+      const cleared: MonitorSteps = databaseRoundTrip(saved);
+      expect(stepValues(cleared.toJSON())[0]).not.toHaveProperty("retryCount");
+    },
+  );
+  test("multiple steps keep their independent inherited and explicit retry settings", (): void => {
+    const steps: MonitorSteps = databaseRoundTrip(
+      MonitorSteps.fromJSON(apiPayload([undefined, 0, 2, null, 3])),
+    );
+    expect(
+      steps.data!.monitorStepsInstanceArray.map(
+        (step: MonitorStep): number | undefined => {
+          return step.data!.retryCount;
+        },
+      ),
+    ).toEqual([undefined, 0, 2, undefined, 3]);
+  });
+});

package/Tests/Types/WebsiteRequest.test.ts CHANGED Viewed

@@ -272,6 +272,50 @@ describe("WebsiteRequest.fetch", () => {
     expect(budget.remainingBytes).toBe(100 - Buffer.byteLength(bodyText));
   });
+  test.each([200, 400, 503])(
+    "should cancel a stalled status %s body even after Axios has settled",
+    async (status: number) => {
+      const controller: AbortController = new AbortController();
+      let resolveReading: () => void = (): void => {};
+      const reading: Promise<void> = new Promise((resolve: () => void) => {
+        resolveReading = resolve;
+      });
+      const body: Readable = new Readable({
+        read: (): void => {
+          resolveReading();
+        },
+      });
+      const response: {
+        status: number;
+        data: Readable;
+        headers: Record<string, string>;
+      } = { status: status, data: body, headers: {} };
+      if (status >= 400) {
+        axiosMock.mockRejectedValueOnce({
+          isAxiosError: true,
+          response: response,
+        });
+      } else {
+        axiosMock.mockResolvedValueOnce(response);
+      }
+      const pending: Promise<WebsiteResponse> = WebsiteRequest.fetch(url, {
+        signal: controller.signal,
+        responseBodyBudget: new HTTPResponseBodyBudget(100),
+      });
+      const rejected: Promise<void> = expect(pending).rejects.toMatchObject({
+        name: "AbortError",
+      });
+      await reading;
+      controller.abort();
+      await rejected;
+      expect(body.destroyed).toBe(true);
+      expect(axiosMock).toHaveBeenCalledTimes(1);
+    },
+  );
   test("should strip a leading UTF-8 BOM from a budgeted HTML stream", async () => {
     const html: string = "<html><body>bounded</body></html>";
     const bodyText: string = `\uFEFF${html}`;