@stanterprise/playwright-reporter 1.0.0 → 1.0.1

package/dist/utils/attachmentProcessor.js

@@ -3,25 +3,54 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.processAttachments = processAttachments;
 exports.extractErrorInfo = extractErrorInfo;
 const protobuf_1 = require("@stanterprise/protobuf");
+const Attachment = protobuf_1.common.v1.common.Attachment;
+/**
+ * Constant for converting bytes to megabytes
+ */
+const BYTES_PER_MB = 1048576;
 /**
  * Process Playwright test attachments into protobuf Attachment objects
+ * @param result Test result or test step containing attachments
+ * @param maxAttachmentSize Maximum size for attachment content (default 1MB, reduced from 10MB)
  */
-function processAttachments(result) {
+function processAttachments(result, maxAttachmentSize = 1048576) {
     const attachments = [];
     if (!result.attachments || result.attachments.length === 0) {
         return attachments;
     }
+    let totalAttachmentSize = 0;
+    const MAX_TOTAL_ATTACHMENT_SIZE = 2097152; // 2MB total limit across all attachments
     for (const attachment of result.attachments) {
-        const att = new protobuf_1.common.Attachment({
+        const att = new Attachment({
             name: attachment.name,
             mime_type: attachment.contentType,
         });
-        // Use path as URI if available, otherwise use the body content
+        // Always prefer path if available to avoid large payloads
         if (attachment.path) {
             att.uri = attachment.path;
+            attachments.push(att);
+            continue;
         }
-        else if (attachment.body) {
+        if (attachment.body) {
+            const bodySize = attachment.body.length;
+            // Check individual attachment size
+            if (bodySize > maxAttachmentSize) {
+                console.warn(`Attachment "${attachment.name}" (${(bodySize / BYTES_PER_MB).toFixed(2)}MB) exceeds max size ` +
+                    `(${(maxAttachmentSize / BYTES_PER_MB).toFixed(2)}MB) and has no path. Skipping content.`);
+                // Still add the attachment metadata without content
+                attachments.push(att);
+                continue;
+            }
+            // Check total accumulated size
+            if (totalAttachmentSize + bodySize > MAX_TOTAL_ATTACHMENT_SIZE) {
+                console.warn(`Attachment "${attachment.name}" (${(bodySize / BYTES_PER_MB).toFixed(2)}MB) would exceed total attachment size limit ` +
+                    `(${(MAX_TOTAL_ATTACHMENT_SIZE / BYTES_PER_MB).toFixed(2)}MB). Skipping content.`);
+                attachments.push(att);
+                continue;
+            }
+            // Include content if within limits
             att.content = attachment.body;
+            totalAttachmentSize += bodySize;
         }
         attachments.push(att);
     }

package/dist/utils/debugLogger.d.ts

@@ -0,0 +1,13 @@
+import { StanterpriseReporterOptions } from "../types";
+/**
+ * Creates or truncates the debug JSONL file so each test run starts with a clean file.
+ * No-op when debug mode is disabled.
+ */
+export declare function initDebugFile(options: StanterpriseReporterOptions): void;
+/**
+ * Appends a single JSONL entry for an outgoing gRPC message.
+ * Each entry is a JSON object on its own line containing the timestamp,
+ * gRPC method path, and the serialized message payload.
+ * No-op when debug mode is disabled.
+ */
+export declare function writeDebugEntry(options: StanterpriseReporterOptions, path: string, message: unknown): Promise<void>;

package/dist/utils/debugLogger.js

@@ -0,0 +1,87 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initDebugFile = initDebugFile;
+exports.writeDebugEntry = writeDebugEntry;
+const fs = __importStar(require("fs"));
+const nodePath = __importStar(require("path"));
+/**
+ * Ensures the parent directory of `filePath` exists, creating it recursively if needed.
+ */
+function ensureParentDir(filePath) {
+    const dir = nodePath.dirname(filePath);
+    if (dir && dir !== ".") {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+/**
+ * Creates or truncates the debug JSONL file so each test run starts with a clean file.
+ * No-op when debug mode is disabled.
+ */
+function initDebugFile(options) {
+    if (!options.debug)
+        return;
+    const filePath = options.debugFile || "stanterprise-debug.jsonl";
+    try {
+        ensureParentDir(filePath);
+        fs.writeFileSync(filePath, "");
+    }
+    catch (e) {
+        console.error(`Stanterprise Reporter: Failed to initialize debug file "${filePath}":`, e);
+    }
+}
+/**
+ * Appends a single JSONL entry for an outgoing gRPC message.
+ * Each entry is a JSON object on its own line containing the timestamp,
+ * gRPC method path, and the serialized message payload.
+ * No-op when debug mode is disabled.
+ */
+async function writeDebugEntry(options, path, message) {
+    if (!options.debug)
+        return;
+    const filePath = options.debugFile || "stanterprise-debug.jsonl";
+    const entry = {
+        timestamp: new Date().toISOString(),
+        path,
+        message,
+    };
+    try {
+        ensureParentDir(filePath);
+        await fs.promises.appendFile(filePath, JSON.stringify(entry) + "\n");
+    }
+    catch (e) {
+        console.error(`Stanterprise Reporter: Failed to write debug entry to "${filePath}":`, e);
+    }
+}

package/dist/utils/envRetriever.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Retrieves environment variables with the STANTERPRISE_META_ prefix
+ * and returns them as a Map with the prefix stripped from keys.
+ *
+ * For example, STANTERPRISE_META_BUILD_ID=123 becomes BUILD_ID=123 in the metadata.
+ *
+ * @returns Map of metadata key-value pairs with prefix removed
+ */
+export declare function getEnvVariables(): Map<string, string>;

package/dist/utils/envRetriever.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnvVariables = getEnvVariables;
+/**
+ * Retrieves environment variables with the STANTERPRISE_META_ prefix
+ * and returns them as a Map with the prefix stripped from keys.
+ *
+ * For example, STANTERPRISE_META_BUILD_ID=123 becomes BUILD_ID=123 in the metadata.
+ *
+ * @returns Map of metadata key-value pairs with prefix removed
+ */
+function getEnvVariables() {
+    const envValues = process.env;
+    const prefix = "STANTERPRISE_META_";
+    const filteredEntries = Object.entries(envValues)
+        .filter(([key]) => key.startsWith(prefix))
+        .map(([key, value]) => {
+        // Strip the STANTERPRISE_META_ prefix so metadata keys are cleaner
+        const strippedKey = key.substring(prefix.length);
+        return [strippedKey, value || ""];
+    });
+    return new Map(filteredEntries);
+}

package/dist/utils/idGenerators.d.ts

@@ -0,0 +1,20 @@
+import { Suite, TestCase, TestStep } from "@playwright/test/reporter";
+/**
+ * Generates a unique suite ID based on the suite's title path.
+ * @param suite The Playwright Suite object.
+ * @returns A unique string ID for the suite.
+ */
+export declare function generateSuiteId(suite: Suite): string;
+/**
+ * Generates a unique test ID based on the test case. Currently uses the test's existing ID.
+ * @param test The Playwright TestCase object.
+ * @returns A unique string ID for the test case.
+ */
+export declare function generateTestId(test: TestCase): string;
+/**
+ * Generates a unique step ID based on the step and its parent test case.
+ * @param step The Playwright TestStep object.
+ * @param test The Playwright TestCase object that the step belongs to.
+ * @returns A unique string ID for the step.
+ */
+export declare function generateStepId(step: TestStep, test: TestCase): string;

package/dist/utils/idGenerators.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSuiteId = generateSuiteId;
+exports.generateTestId = generateTestId;
+exports.generateStepId = generateStepId;
+const crypto_1 = __importDefault(require("crypto"));
+/**
+ * Generates a unique suite ID based on the suite's title path.
+ * @param suite The Playwright Suite object.
+ * @returns A unique string ID for the suite.
+ */
+function generateSuiteId(suite) {
+    return crypto_1.default
+        .createHash("sha256")
+        .update(suite.titlePath().join(":"))
+        .digest("hex");
+}
+/**
+ * Generates a unique test ID based on the test case. Currently uses the test's existing ID.
+ * @param test The Playwright TestCase object.
+ * @returns A unique string ID for the test case.
+ */
+function generateTestId(test) {
+    return test.id;
+}
+/**
+ * Generates a unique step ID based on the step and its parent test case.
+ * @param step The Playwright TestStep object.
+ * @param test The Playwright TestCase object that the step belongs to.
+ * @returns A unique string ID for the step.
+ */
+function generateStepId(step, test) {
+    return crypto_1.default
+        .createHash("sha256")
+        .update(`${test.id}:${step.titlePath().join(":")}`)
+        .digest("hex");
+}

package/dist/utils/index.d.ts

@@ -4,3 +4,7 @@
 export * from "./statusMapper";
 export * from "./attachmentProcessor";
 export * from "./timeHelpers";
+export * from "./idGenerators";
+export * from "./envRetriever";
+export * from "./metadataHelpers";
+export * from "./debugLogger";

package/dist/utils/index.js

@@ -20,3 +20,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./statusMapper"), exports);
 __exportStar(require("./attachmentProcessor"), exports);
 __exportStar(require("./timeHelpers"), exports);
+__exportStar(require("./idGenerators"), exports);
+__exportStar(require("./envRetriever"), exports);
+__exportStar(require("./metadataHelpers"), exports);
+__exportStar(require("./debugLogger"), exports);

package/dist/utils/metadataHelpers.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Utility functions for building metadata objects
+ */
+import type { TestCase, TestResult, TestStep } from "@playwright/test/reporter";
+/**
+ * Truncate a string to a maximum length with ellipsis indicator
+ * @param value String value to truncate
+ * @param maxLength Maximum length (default 100KB)
+ * @returns Truncated string with warning suffix if truncated
+ */
+export declare function truncateValue(value: string, maxLength?: number): string;
+/**
+ * Build metadata from annotations array
+ * @param annotations Array of annotations with type and optional description
+ * @param prefix Prefix for metadata keys (e.g., "annotation", "result_annotation")
+ * @returns Record of metadata key-value pairs
+ */
+export declare function buildAnnotationsMetadata(annotations: Array<{
+    type: string;
+    description?: string;
+}>, prefix?: string): Record<string, string>;
+/**
+ * Build metadata from test case and result annotations
+ * Combines annotations from both the test case and the result
+ * @param test Test case containing annotations
+ * @param result Test result containing additional annotations
+ * @returns Record of metadata key-value pairs
+ */
+export declare function buildTestMetadata(test: TestCase, result: TestResult): Record<string, string>;
+/**
+ * Build metadata from step annotations and category
+ * @param step Test step containing annotations and category
+ * @returns Record of metadata key-value pairs
+ */
+export declare function buildStepMetadata(step: TestStep): Record<string, string>;
+/**
+ * Convert metadata object to Map for protobuf serialization
+ * Protobuf requires Map<string, string> for metadata fields
+ * @param metadata Record of metadata key-value pairs
+ * @returns Map ready for protobuf constructors
+ */
+export declare function toMetadataMap(metadata: Record<string, string>): Map<string, string>;

package/dist/utils/metadataHelpers.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truncateValue = truncateValue;
+exports.buildAnnotationsMetadata = buildAnnotationsMetadata;
+exports.buildTestMetadata = buildTestMetadata;
+exports.buildStepMetadata = buildStepMetadata;
+exports.toMetadataMap = toMetadataMap;
+/**
+ * Maximum length for a single metadata value (100KB)
+ * Large values are often accidentally embedded test data or debug output
+ */
+const MAX_METADATA_VALUE_LENGTH = 102400;
+/**
+ * Maximum total metadata size across all values (1MB)
+ */
+const MAX_TOTAL_METADATA_SIZE = 1048576;
+/**
+ * Truncate a string to a maximum length with ellipsis indicator
+ * @param value String value to truncate
+ * @param maxLength Maximum length (default 100KB)
+ * @returns Truncated string with warning suffix if truncated
+ */
+function truncateValue(value, maxLength = MAX_METADATA_VALUE_LENGTH) {
+    if (value.length <= maxLength) {
+        return value;
+    }
+    const truncated = value.substring(0, maxLength - 100);
+    return `${truncated}... [TRUNCATED: original length ${value.length} bytes, showing first ${maxLength - 100} bytes]`;
+}
+/**
+ * Build metadata from annotations array
+ * @param annotations Array of annotations with type and optional description
+ * @param prefix Prefix for metadata keys (e.g., "annotation", "result_annotation")
+ * @returns Record of metadata key-value pairs
+ */
+function buildAnnotationsMetadata(annotations, prefix = "annotation") {
+    const metadata = {};
+    let totalSize = 0;
+    for (let index = 0; index < annotations.length; index++) {
+        const annotation = annotations[index];
+        const typeKey = `${prefix}_${index}_type`;
+        const typeValue = annotation.type;
+        metadata[typeKey] = typeValue;
+        totalSize += typeValue.length;
+        if (annotation.description) {
+            const descKey = `${prefix}_${index}_description`;
+            const descValue = truncateValue(annotation.description);
+            // Skip if adding this would exceed total metadata size
+            if (totalSize + descValue.length > MAX_TOTAL_METADATA_SIZE) {
+                console.warn(`Skipping annotation description for ${typeKey}: would exceed total metadata size limit (${MAX_TOTAL_METADATA_SIZE} bytes)`);
+                continue;
+            }
+            metadata[descKey] = descValue;
+            totalSize += descValue.length;
+        }
+    }
+    return metadata;
+}
+/**
+ * Build metadata from test case and result annotations
+ * Combines annotations from both the test case and the result
+ * @param test Test case containing annotations
+ * @param result Test result containing additional annotations
+ * @returns Record of metadata key-value pairs
+ */
+function buildTestMetadata(test, result) {
+    return {
+        ...buildAnnotationsMetadata(test.annotations, "annotation"),
+        ...buildAnnotationsMetadata(result.annotations, "result_annotation"),
+    };
+}
+/**
+ * Build metadata from step annotations and category
+ * @param step Test step containing annotations and category
+ * @returns Record of metadata key-value pairs
+ */
+function buildStepMetadata(step) {
+    return {
+        category: step.category,
+        ...buildAnnotationsMetadata(step.annotations, "annotation"),
+    };
+}
+/**
+ * Convert metadata object to Map for protobuf serialization
+ * Protobuf requires Map<string, string> for metadata fields
+ * @param metadata Record of metadata key-value pairs
+ * @returns Map ready for protobuf constructors
+ */
+function toMetadataMap(metadata) {
+    return new Map(Object.entries(metadata));
+}

package/dist/utils/optionsMapper.d.ts

@@ -0,0 +1,7 @@
+import { StanterpriseReporterOptions } from "../types";
+/**
+ * Define and map reporter options from provided options and environment variables. Apply defaults where necessary.
+ * @param providedOptions Options provided during reporter initialization
+ * @returns Mapped and completed StanterpriseReporterOptions
+ */
+export default function defineOptions(providedOptions: StanterpriseReporterOptions): StanterpriseReporterOptions;

package/dist/utils/optionsMapper.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = defineOptions;
+/**
+ * Define and map reporter options from provided options and environment variables. Apply defaults where necessary.
+ * @param providedOptions Options provided during reporter initialization
+ * @returns Mapped and completed StanterpriseReporterOptions
+ */
+function defineOptions(providedOptions) {
+    const result = {};
+    result.grpcAddress = identifyAddress(providedOptions);
+    result.grpcEnabled =
+        providedOptions.grpcEnabled ??
+            (process.env.STANTERPRISE_GRPC_ENABLED || "true").toLowerCase() !== "false";
+    result.grpcTimeout = providedOptions.grpcTimeout ?? 1000;
+    result.grpcMaxMessageSize = providedOptions.grpcMaxMessageSize ?? 104857600;
+    result.maxAttachmentSize = providedOptions.maxAttachmentSize ?? 10485760;
+    result.verbose = providedOptions.verbose ?? false;
+    result.grpcMaxRetries = providedOptions.grpcMaxRetries ?? 3;
+    result.grpcRetryDelay = providedOptions.grpcRetryDelay ?? 100;
+    result.debug =
+        providedOptions.debug ??
+            (process.env.STANTERPRISE_DEBUG || "").toLowerCase() === "true";
+    result.debugFile =
+        providedOptions.debugFile ||
+            process.env.STANTERPRISE_DEBUG_FILE ||
+            "stanterprise-debug.jsonl";
+    result.tls =
+        providedOptions.tls ??
+            (process.env.STANTERPRISE_GRPC_TLS || "true").toLowerCase() === "true";
+    return result;
+}
+function identifyAddress(providedOptions) {
+    if (providedOptions.grpcAddress) {
+        return providedOptions.grpcAddress;
+    }
+    if (process.env.STANTERPRISE_GRPC_ADDRESS) {
+        return process.env.STANTERPRISE_GRPC_ADDRESS;
+    }
+    if (process.env.STANTERPRISE_GRPC_HOST) {
+        const host = process.env.STANTERPRISE_GRPC_HOST;
+        const port = process.env.STANTERPRISE_GRPC_PORT || "50051";
+        return `${host}:${port}`;
+    }
+    if (providedOptions.grpcHost) {
+        const host = providedOptions.grpcHost;
+        const port = providedOptions.grpcPort ?? 50051;
+        return `${host}:${port}`;
+    }
+    return "localhost:50051";
+}

package/dist/utils/statusMapper.js

@@ -3,26 +3,27 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.mapTestStatus = mapTestStatus;
 exports.mapStepStatus = mapStepStatus;
 const protobuf_1 = require("@stanterprise/protobuf");
+const TestStatus = protobuf_1.common.v1.common.TestStatus;
 /**
  * Map Playwright test status to protobuf TestStatus
  */
 function mapTestStatus(status) {
     switch (status) {
         case "passed":
-            return protobuf_1.common.TestStatus.PASSED;
+            return TestStatus.PASSED;
         case "failed":
-            return protobuf_1.common.TestStatus.FAILED;
+            return TestStatus.FAILED;
         case "skipped":
-            return protobuf_1.common.TestStatus.SKIPPED;
+            return TestStatus.SKIPPED;
         case "timedOut":
-            return protobuf_1.common.TestStatus.FAILED; // Treat timeout as failed
+            return TestStatus.FAILED; // Treat timeout as failed
         default:
-            return protobuf_1.common.TestStatus.UNKNOWN;
+            return TestStatus.UNKNOWN;
     }
 }
 /**
  * Map step error to test status
  */
 function mapStepStatus(hasError) {
-    return hasError ? protobuf_1.common.TestStatus.FAILED : protobuf_1.common.TestStatus.PASSED;
+    return hasError ? TestStatus.FAILED : TestStatus.PASSED;
 }

package/dist/utils/timeHelpers.d.ts

@@ -2,15 +2,15 @@
  * Utility functions for creating timestamps and durations
  */
 import { google } from "@stanterprise/protobuf";
-import type { google as googleTypes } from "@stanterprise/protobuf/dist/lib/google/protobuf/duration";
+declare const Timestamp: typeof google.google.protobuf.Timestamp;
 /**
  * Create a protobuf Timestamp from a JavaScript Date
  */
-export declare function createTimestamp(date: Date): InstanceType<typeof google.protobuf.Timestamp>;
+export declare function createTimestamp(date: Date): InstanceType<typeof Timestamp>;
 /**
  * Create a protobuf Timestamp from milliseconds since epoch
  */
-export declare function createTimestampFromMs(ms: number): InstanceType<typeof google.protobuf.Timestamp>;
+export declare function createTimestampFromMs(ms: number): InstanceType<typeof Timestamp>;
 /**
  * Create a duration object from milliseconds.
  *
@@ -18,9 +18,9 @@ export declare function createTimestampFromMs(ms: number): InstanceType<typeof g
  * but not exported in the package's main barrel export. Since Duration and Timestamp
  * have identical structure (seconds: number, nanos: number) and the protobuf serialization
  * is wire-compatible, we use Timestamp as a Duration substitute. This works correctly at runtime.
- * The return type is cast to Duration for proper type checking with the schema.
  *
  * @param durationMs Duration in milliseconds
  * @returns A Duration object (implemented as Timestamp due to export limitations)
  */
-export declare function createDuration(durationMs: number): googleTypes.protobuf.Duration;
+export declare function createDuration(durationMs: number): any;
+export {};

package/dist/utils/timeHelpers.js

@@ -7,22 +7,32 @@ exports.createDuration = createDuration;
  * Utility functions for creating timestamps and durations
  */
 const protobuf_1 = require("@stanterprise/protobuf");
+const Timestamp = protobuf_1.google.google.protobuf.Timestamp;
 /**
  * Create a protobuf Timestamp from a JavaScript Date
  */
 function createTimestamp(date) {
-    return new protobuf_1.google.protobuf.Timestamp({
-        seconds: Math.floor(date.getTime() / 1000),
-        nanos: (date.getTime() % 1000) * 1000000,
+    const ms = date.getTime();
+    // Validate to prevent NaN from causing protobuf serialization failures
+    if (isNaN(ms)) {
+        throw new Error(`Invalid date provided to createTimestamp: ${date.toString()}`);
+    }
+    return new Timestamp({
+        seconds: Math.floor(ms / 1000),
+        nanos: Math.floor((ms % 1000) * 1000000),
     });
 }
 /**
  * Create a protobuf Timestamp from milliseconds since epoch
  */
 function createTimestampFromMs(ms) {
-    return new protobuf_1.google.protobuf.Timestamp({
+    // Validate to prevent NaN from causing protobuf serialization failures
+    if (typeof ms !== "number" || isNaN(ms)) {
+        throw new Error(`Invalid milliseconds provided to createTimestampFromMs: ${ms}`);
+    }
+    return new Timestamp({
         seconds: Math.floor(ms / 1000),
-        nanos: (ms % 1000) * 1000000,
+        nanos: Math.floor((ms % 1000) * 1000000),
     });
 }
 /**
@@ -32,14 +42,20 @@ function createTimestampFromMs(ms) {
  * but not exported in the package's main barrel export. Since Duration and Timestamp
  * have identical structure (seconds: number, nanos: number) and the protobuf serialization
  * is wire-compatible, we use Timestamp as a Duration substitute. This works correctly at runtime.
- * The return type is cast to Duration for proper type checking with the schema.
  *
  * @param durationMs Duration in milliseconds
  * @returns A Duration object (implemented as Timestamp due to export limitations)
  */
 function createDuration(durationMs) {
-    return new protobuf_1.google.protobuf.Timestamp({
+    // Validate to prevent NaN from causing protobuf serialization failures
+    if (typeof durationMs !== "number" || isNaN(durationMs)) {
+        throw new Error(`Invalid duration provided to createDuration: ${durationMs}`);
+    }
+    if (durationMs < 0) {
+        throw new Error(`Negative duration provided to createDuration: ${durationMs}`);
+    }
+    return new Timestamp({
         seconds: Math.floor(durationMs / 1000),
-        nanos: (durationMs % 1000) * 1000000,
+        nanos: Math.floor((durationMs % 1000) * 1000000),
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stanterprise/playwright-reporter",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Custom Playwright test reporter that sends test results to Stanterprise via gRPC",
   "homepage": "https://github.com/stanterprise/stanterprise-playwright-reporter#readme",
   "bugs": {
@@ -16,8 +16,7 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
-    "dist/**/*",
-    "README.md"
+    "dist/**/*"
   ],
   "keywords": [
     "playwright",
@@ -44,9 +43,9 @@
   },
   "devDependencies": {
     "@playwright/test": "^1.52.0",
-    "@types/jest": "^30.0.0",
-    "@types/node": "^22.15.29",
-    "jest": "^30.2.0",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.19.7",
+    "jest": "^29.7.0",
     "ts-jest": "^29.4.5",
     "typescript": "^5.9.3"
   },
@@ -54,6 +53,6 @@
     "@grpc/grpc-js": "^1.14.1",
     "@protobuf-ts/grpc-transport": "^2.11.1",
     "@protobuf-ts/grpcweb-transport": "^2.11.1",
-    "@stanterprise/protobuf": "^0.0.9"
+    "@stanterprise/protobuf": "^0.1.3"
   }
 }