@stanterprise/playwright-reporter 0.0.0-debug-flag-2

package/dist/types.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Type definitions for Stanterprise Playwright Reporter
+ */
+/**
+ * Configuration options for the Stanterprise Reporter
+ */
+export interface StanterpriseReporterOptions {
+    /**
+     * gRPC server address
+     * @default "localhost:50051" or process.env.STANTERPRISE_GRPC_ADDRESS
+     */
+    grpcAddress?: string;
+    /**
+     * Whether gRPC reporting is enabled
+     * @default true or process.env.STANTERPRISE_GRPC_ENABLED !== "false"
+     */
+    grpcEnabled?: boolean;
+    /**
+     * Timeout for gRPC calls in milliseconds
+     * @default 1000
+     */
+    grpcTimeout?: number;
+    /**
+     * Maximum message size for gRPC calls in bytes
+     * @default 104857600 (100MB)
+     */
+    grpcMaxMessageSize?: number;
+    /**
+     * Maximum size for attachment content in bytes
+     * Attachments larger than this will only include the path reference
+     * @default 10485760 (10MB)
+     */
+    maxAttachmentSize?: number;
+    /**
+     * Whether to include verbose logging
+     * @default false
+     */
+    verbose?: boolean;
+    /**
+     * Maximum number of retry attempts for failed gRPC calls
+     * @default 3
+     */
+    grpcMaxRetries?: number;
+    /**
+     * Initial delay between retry attempts in milliseconds
+     * Actual delay uses exponential backoff: initialDelay * (2 ^ attemptNumber)
+     * @default 100
+     */
+    grpcRetryDelay?: number;
+    /**
+     * Whether to enable debug mode, which writes all outgoing gRPC messages to a JSONL file
+     * @default false or process.env.STANTERPRISE_DEBUG === "true"
+     */
+    debug?: boolean;
+    /**
+     * File path for debug JSONL output when debug mode is enabled
+     * @default "stanterprise-debug.jsonl" or process.env.STANTERPRISE_DEBUG_FILE
+     */
+    debugFile?: string;
+}
+/**
+ * Internal type for managing test execution state
+ */
+export interface TestExecutionContext {
+    /**
+     * Unique ID combining run ID and test ID
+     */
+    uniqueTestExecutionId: string;
+    /**
+     * The global run ID for this test execution
+     */
+    runId: string;
+    /**
+     * The test ID from Playwright
+     */
+    testId: string;
+}
+/**
+ * Internal type for managing step execution state
+ */
+export interface StepExecutionContext extends TestExecutionContext {
+    /**
+     * Unique ID for the step
+     */
+    uniqueStepId: string;
+    /**
+     * Step title
+     */
+    stepTitle: string;
+    /**
+     * Step start time
+     */
+    stepStartTime: Date;
+}

package/dist/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Type definitions for Stanterprise Playwright Reporter
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/attachmentProcessor.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Utility functions for processing test attachments
+ */
+import type { TestResult } from "@playwright/test/reporter";
+import { common } from "@stanterprise/protobuf";
+declare const Attachment: typeof common.v1.common.Attachment;
+/**
+ * Process Playwright test attachments into protobuf Attachment objects
+ * @param result Test result containing attachments
+ * @param maxAttachmentSize Maximum size for attachment content (default 1MB, reduced from 10MB)
+ */
+export declare function processAttachments(result: TestResult, maxAttachmentSize?: number): InstanceType<typeof Attachment>[];
+/**
+ * Extract error information from test results
+ */
+export declare function extractErrorInfo(result: TestResult): {
+    errorMessage: string;
+    stackTrace: string;
+    errors: string[];
+};
+export {};

package/dist/utils/attachmentProcessor.js

@@ -0,0 +1,73 @@
+"use strict";
+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 containing attachments
+ * @param maxAttachmentSize Maximum size for attachment content (default 1MB, reduced from 10MB)
+ */
+function processAttachments(result, maxAttachmentSize = 1048576 // 1MB default (reduced from 10MB to prevent large payloads)
+) {
+    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 Attachment({
+            name: attachment.name,
+            mime_type: attachment.contentType,
+        });
+        // Always prefer path if available to avoid large payloads
+        if (attachment.path) {
+            att.uri = attachment.path;
+            attachments.push(att);
+            continue;
+        }
+        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);
+    }
+    return attachments;
+}
+/**
+ * Extract error information from test results
+ */
+function extractErrorInfo(result) {
+    let errorMessage = "";
+    let stackTrace = "";
+    const errors = [];
+    if (result.errors && result.errors.length > 0) {
+        errorMessage = result.errors.map((e) => e.message || "").join("\n");
+        stackTrace = result.errors.map((e) => e.stack || "").join("\n");
+        errors.push(...result.errors.map((e) => e.message || ""));
+    }
+    return { errorMessage, stackTrace, errors };
+}

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): void;

package/dist/utils/debugLogger.js

@@ -0,0 +1,75 @@
+"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"));
+/**
+ * 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 {
+        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.
+ */
+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 {
+        fs.appendFileSync(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

@@ -0,0 +1,10 @@
+/**
+ * Utility exports - centralized access to all utility functions
+ */
+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

@@ -0,0 +1,26 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Utility exports - centralized access to all utility functions
+ */
+__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,31 @@
+"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 =
+        providedOptions.grpcAddress ||
+            process.env.STANTERPRISE_GRPC_ADDRESS ||
+            "localhost:50051";
+    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 === "true";
+    result.debugFile =
+        providedOptions.debugFile ||
+            process.env.STANTERPRISE_DEBUG_FILE ||
+            "stanterprise-debug.jsonl";
+    return result;
+}

package/dist/utils/statusMapper.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Utility functions for mapping Playwright types to protobuf types
+ */
+import type { TestResult } from "@playwright/test/reporter";
+/**
+ * Map Playwright test status to protobuf TestStatus
+ */
+export declare function mapTestStatus(status: TestResult["status"]): number;
+/**
+ * Map step error to test status
+ */
+export declare function mapStepStatus(hasError: boolean): number;

package/dist/utils/statusMapper.js

@@ -0,0 +1,29 @@
+"use strict";
+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 TestStatus.PASSED;
+        case "failed":
+            return TestStatus.FAILED;
+        case "skipped":
+            return TestStatus.SKIPPED;
+        case "timedOut":
+            return TestStatus.FAILED; // Treat timeout as failed
+        default:
+            return TestStatus.UNKNOWN;
+    }
+}
+/**
+ * Map step error to test status
+ */
+function mapStepStatus(hasError) {
+    return hasError ? TestStatus.FAILED : TestStatus.PASSED;
+}

package/dist/utils/timeHelpers.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Utility functions for creating timestamps and durations
+ */
+import { google } from "@stanterprise/protobuf";
+declare const Timestamp: typeof google.google.protobuf.Timestamp;
+/**
+ * Create a protobuf Timestamp from a JavaScript Date
+ */
+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 Timestamp>;
+/**
+ * Create a duration object from milliseconds.
+ *
+ * NOTE: google.protobuf.Duration is defined in the @stanterprise/protobuf schema
+ * 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.
+ *
+ * @param durationMs Duration in milliseconds
+ * @returns A Duration object (implemented as Timestamp due to export limitations)
+ */
+export declare function createDuration(durationMs: number): any;
+export {};