testpulse-jest 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Barayo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,118 @@
+# testpulse-jest
+
+A Jest reporter + [`jest-junit`](https://github.com/jest-community/jest-junit)
+companion for reporting Jest results into
+[TestPulse](https://github.com/Barayo/TestPulse) — matches each test to an
+existing TestPulse case by key and submits the run automatically.
+
+Jest has no built-in way for a running test to attach custom metadata to
+its own result (no `record_property()`-equivalent). `testpulse-jest` works
+around that by tagging tests through a small wrapper, injecting the case
+key into `jest-junit`'s own JUnit XML output via its property hook, and
+then submitting that report.
+
+## Install
+
+```bash
+npm install --save-dev testpulse-jest jest-junit
+```
+
+## Configure
+
+Three pieces need to be wired into `jest.config.js`: `jest-junit` itself,
+the property-injection hook this package ships (which needs a
+`path.dirname()`/`path.basename()` split — `jest-junit` joins its two
+`testCaseProperties*` options with `path.join()`, which mangles a single
+combined absolute path), and this package's own reporter, **listed after
+`jest-junit`**:
+
+```js
+// jest.config.js
+const path = require('path');
+const propsPath = require.resolve('testpulse-jest/junitTestCaseProperties');
+
+module.exports = {
+  reporters: [
+    'default',
+    ['jest-junit', {
+      outputName: 'junit.xml',
+      // jest-junit's default suiteNameTemplate ("{title}") resolves to the
+      // literal string "undefined" for a flat test() with no enclosing
+      // describe() -- {filepath} always names the run meaningfully.
+      suiteNameTemplate: '{filepath}',
+      testCasePropertiesDirectory: path.dirname(propsPath),
+      testCasePropertiesFile: path.basename(propsPath),
+    }],
+    ['testpulse-jest', {
+      url: 'http://localhost:8080',
+      project: 'LOGIN',
+    }],
+  ],
+};
+```
+
+## Tag your tests
+
+```js
+const { testpulse, testpulseAttach } = require('testpulse-jest');
+
+testpulse('LOGIN-42', { platform: 'linux', tags: ['smoke'] })(
+  'logs in successfully',
+  async () => {
+    // ...
+  }
+);
+
+testpulse('LOGIN-43')('fails with a bad password', async () => {
+  const screenshot = await page.screenshot();
+  await testpulseAttach(screenshot, { filename: 'failure.png', contentType: 'image/png' });
+  // ...
+});
+```
+
+`testpulse()` wraps `test`/`it` — the test's own title is never modified,
+so nothing shows up differently in console output, CI logs, or the JUnit
+report's own `<testcase name>`. `testpulseAttach()` only accepts
+`image/png`, `image/jpeg`, and `image/webp`, and only works inside a test
+already tagged via `testpulse()` — calling it from an untagged test logs a
+warning and drops the attachment.
+
+## Configuration reference
+
+Each setting resolves from an environment variable first, falling back to
+the matching reporter option in `jest.config.js`:
+
+| Setting | Env var | Reporter option |
+|---|---|---|
+| API base URL | `TESTPULSE_URL` | `url` |
+| API token | `TESTPULSE_TOKEN` | `token` |
+| Project key | `TESTPULSE_PROJECT` | `project` |
+| Fail build on unmatched cases | `TESTPULSE_FAIL_ON_UNMATCHED` | `failOnUnmatched` |
+| Dry run (preview only) | `TESTPULSE_DRY_RUN` | `dryRun` |
+| jest-junit output path | — | `junitFile` (default `./junit.xml`) |
+| Scratch directory | — | `scratchDir` (default `.testpulse/`) |
+| Keep scratch dir after run | — | `keepScratchDir` (default `false`) |
+
+Put the token in `TESTPULSE_TOKEN` (a CI secret), not in a committed
+`jest.config.js` — the reporter option exists but env var wins, so a
+committed placeholder never accidentally shadows the real secret.
+
+`--testpulse` isn't a real CLI flag family here — Jest owns the CLI, so
+all of this is configured via `jest.config.js`'s `reporters` entry and env
+vars, not command-line flags.
+
+## Build outcome
+
+| API response | Behavior |
+|---|---|
+| `201` all matched | build succeeds; summary logged |
+| `207` some unmatched | build succeeds by default (unmatched case keys + `failOnUnmatched` pointer logged); fails when `failOnUnmatched` is set |
+| network/auth/4xx/5xx error | always fails the build, unconditionally |
+
+`dryRun: true` (or `TESTPULSE_DRY_RUN=1`) previews matches via a read-only
+`GET /cases` request and never submits anything — never affects the exit
+code.
+
+## License
+
+MIT

package/dist/attachmentStore.d.ts

@@ -0,0 +1,14 @@
+export declare const SUPPORTED_CONTENT_TYPES: readonly ["image/png", "image/jpeg", "image/webp"];
+export type SupportedContentType = (typeof SUPPORTED_CONTENT_TYPES)[number];
+export declare const MAX_ATTACHMENT_BYTES: number;
+export interface AttachmentMetadata {
+    fullName: string;
+    filename: string;
+    contentType: SupportedContentType;
+}
+export interface WrittenAttachment extends AttachmentMetadata {
+    dataPath: string;
+}
+export declare function isSupportedContentType(contentType: string): contentType is SupportedContentType;
+export declare function writeAttachment(scratchDir: string, fullName: string, data: Buffer, filename: string, contentType: string): void;
+export declare function readAllAttachments(scratchDir: string): WrittenAttachment[];

package/dist/attachmentStore.js

@@ -0,0 +1,78 @@
+"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.MAX_ATTACHMENT_BYTES = exports.SUPPORTED_CONTENT_TYPES = void 0;
+exports.isSupportedContentType = isSupportedContentType;
+exports.writeAttachment = writeAttachment;
+exports.readAllAttachments = readAllAttachments;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const scratchDir_1 = require("./scratchDir");
+exports.SUPPORTED_CONTENT_TYPES = ['image/png', 'image/jpeg', 'image/webp'];
+// A screenshot this large is almost certainly a mistake (wrong file, an
+// uncompressed capture) -- failing fast here with a clear message beats
+// finding out via a slow timeout or a 413 from the server after the whole
+// base64 payload has already been built and sent.
+exports.MAX_ATTACHMENT_BYTES = 10 * 1024 * 1024;
+function isSupportedContentType(contentType) {
+    return exports.SUPPORTED_CONTENT_TYPES.includes(contentType);
+}
+function writeAttachment(scratchDir, fullName, data, filename, contentType) {
+    if (!isSupportedContentType(contentType)) {
+        throw new Error(`testpulse-jest: testpulseAttach() only supports ${exports.SUPPORTED_CONTENT_TYPES.join(', ')}, got: ${contentType}`);
+    }
+    if (data.length > exports.MAX_ATTACHMENT_BYTES) {
+        throw new Error(`testpulse-jest: testpulseAttach() attachment is ${data.length} bytes, exceeding the ${exports.MAX_ATTACHMENT_BYTES}-byte limit.`);
+    }
+    const dir = (0, scratchDir_1.attachmentsDir)(scratchDir);
+    fs.mkdirSync(dir, { recursive: true });
+    const hashed = (0, scratchDir_1.hashFullName)(fullName);
+    const metadata = { fullName, filename, contentType };
+    fs.writeFileSync(path.join(dir, `${hashed}.json`), JSON.stringify(metadata), 'utf8');
+    fs.writeFileSync(path.join(dir, `${hashed}.data`), data);
+}
+function readAllAttachments(scratchDir) {
+    const dir = (0, scratchDir_1.attachmentsDir)(scratchDir);
+    if (!fs.existsSync(dir))
+        return [];
+    return fs
+        .readdirSync(dir)
+        .filter((f) => f.endsWith('.json'))
+        .map((f) => {
+        const metadata = JSON.parse(fs.readFileSync(path.join(dir, f), 'utf8'));
+        const dataPath = path.join(dir, f.replace(/\.json$/, '.data'));
+        return { ...metadata, dataPath };
+    });
+}

package/dist/caseStore.d.ts

@@ -0,0 +1,15 @@
+export interface CaseMetadata {
+    fullName: string;
+    caseKey: string;
+    platform?: string;
+    version?: string;
+    tags?: string[];
+}
+export interface CaseOptions {
+    platform?: string;
+    version?: string;
+    tags?: string[];
+}
+export declare function writeCaseMetadata(scratchDir: string, fullName: string, caseKey: string, opts?: CaseOptions): void;
+export declare function readCaseMetadata(scratchDir: string, fullName: string): CaseMetadata | undefined;
+export declare function readAllCaseMetadata(scratchDir: string): CaseMetadata[];

package/dist/caseStore.js

@@ -0,0 +1,68 @@
+"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.writeCaseMetadata = writeCaseMetadata;
+exports.readCaseMetadata = readCaseMetadata;
+exports.readAllCaseMetadata = readAllCaseMetadata;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const scratchDir_1 = require("./scratchDir");
+function writeCaseMetadata(scratchDir, fullName, caseKey, opts = {}) {
+    const metadata = {
+        fullName,
+        caseKey,
+        ...(opts.platform ? { platform: opts.platform } : {}),
+        ...(opts.version ? { version: opts.version } : {}),
+        ...(opts.tags && opts.tags.length > 0 ? { tags: opts.tags } : {}),
+    };
+    const dir = (0, scratchDir_1.casesDir)(scratchDir);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, `${(0, scratchDir_1.hashFullName)(fullName)}.json`), JSON.stringify(metadata), 'utf8');
+}
+function readCaseMetadata(scratchDir, fullName) {
+    const file = path.join((0, scratchDir_1.casesDir)(scratchDir), `${(0, scratchDir_1.hashFullName)(fullName)}.json`);
+    if (!fs.existsSync(file))
+        return undefined;
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+function readAllCaseMetadata(scratchDir) {
+    const dir = (0, scratchDir_1.casesDir)(scratchDir);
+    if (!fs.existsSync(dir))
+        return [];
+    return fs
+        .readdirSync(dir)
+        .filter((f) => f.endsWith('.json'))
+        .map((f) => JSON.parse(fs.readFileSync(path.join(dir, f), 'utf8')));
+}

package/dist/config.d.ts

@@ -0,0 +1,23 @@
+export declare const DEFAULT_JUNIT_FILE = "./junit.xml";
+export interface ReporterOptions {
+    url?: string;
+    token?: string;
+    project?: string;
+    failOnUnmatched?: boolean;
+    dryRun?: boolean;
+    junitFile?: string;
+    scratchDir?: string;
+    keepScratchDir?: boolean;
+}
+export interface ResolvedConfig {
+    url?: string;
+    token?: string;
+    project?: string;
+    failOnUnmatched: boolean;
+    dryRun: boolean;
+    junitFile: string;
+    scratchDir: string;
+    keepScratchDir: boolean;
+}
+/** Env var always wins over the reporter's own `jest.config.js` options -- see design.md. */
+export declare function resolveConfig(options?: ReporterOptions): ResolvedConfig;

package/dist/config.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_JUNIT_FILE = void 0;
+exports.resolveConfig = resolveConfig;
+const scratchDir_1 = require("./scratchDir");
+exports.DEFAULT_JUNIT_FILE = './junit.xml';
+function resolveString(envVar, optionValue) {
+    const envValue = process.env[envVar];
+    if (envValue !== undefined && envValue !== '')
+        return envValue;
+    return optionValue;
+}
+function resolveBoolean(envVar, optionValue) {
+    const envValue = process.env[envVar];
+    if (envValue !== undefined && envValue !== '')
+        return envValue === 'true' || envValue === '1';
+    return optionValue ?? false;
+}
+/** Env var always wins over the reporter's own `jest.config.js` options -- see design.md. */
+function resolveConfig(options = {}) {
+    return {
+        url: resolveString('TESTPULSE_URL', options.url),
+        token: resolveString('TESTPULSE_TOKEN', options.token),
+        project: resolveString('TESTPULSE_PROJECT', options.project),
+        failOnUnmatched: resolveBoolean('TESTPULSE_FAIL_ON_UNMATCHED', options.failOnUnmatched),
+        dryRun: resolveBoolean('TESTPULSE_DRY_RUN', options.dryRun),
+        junitFile: options.junitFile ?? exports.DEFAULT_JUNIT_FILE,
+        scratchDir: options.scratchDir ?? scratchDir_1.DEFAULT_SCRATCH_DIR,
+        keepScratchDir: options.keepScratchDir ?? false,
+    };
+}

package/dist/describeStack.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Tracks the currently-executing `describe()` nesting by patching the
+ * global `describe` (and `.only`/`.skip`) the first time this module is
+ * used. `describe` blocks run synchronously during Jest's collection
+ * phase (before any test body executes), so this lets testpulse() know
+ * a test's ancestorTitles at *registration* time -- unlike
+ * `expect.getState().currentTestName`, which is only available once a
+ * test body actually starts running.
+ *
+ * Known limitation: `describe.each` is not patched -- jest-circus's
+ * `.each` implementation calls its own internal `describe` reference
+ * rather than looking up `globalThis.describe` per call, so blocks
+ * created via `.each` won't be reflected in the tracked stack. A test
+ * tagged inside a `describe.each` block still gets correct metadata once
+ * it actually runs (the execution-time write in testpulse.ts recomputes
+ * the real fullName from `expect.getState()` and overwrites the
+ * registration-time sidecar), so this only affects the "still linked
+ * even if skipped/filtered" guarantee for that specific nesting case.
+ */
+export declare function getDescribeStack(): string[];
+export declare function ensureDescribeTracked(): void;
+/** Test-only: reset patch state and stack between test cases. */
+export declare function __resetDescribeStackForTests(): void;

package/dist/describeStack.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * Tracks the currently-executing `describe()` nesting by patching the
+ * global `describe` (and `.only`/`.skip`) the first time this module is
+ * used. `describe` blocks run synchronously during Jest's collection
+ * phase (before any test body executes), so this lets testpulse() know
+ * a test's ancestorTitles at *registration* time -- unlike
+ * `expect.getState().currentTestName`, which is only available once a
+ * test body actually starts running.
+ *
+ * Known limitation: `describe.each` is not patched -- jest-circus's
+ * `.each` implementation calls its own internal `describe` reference
+ * rather than looking up `globalThis.describe` per call, so blocks
+ * created via `.each` won't be reflected in the tracked stack. A test
+ * tagged inside a `describe.each` block still gets correct metadata once
+ * it actually runs (the execution-time write in testpulse.ts recomputes
+ * the real fullName from `expect.getState()` and overwrites the
+ * registration-time sidecar), so this only affects the "still linked
+ * even if skipped/filtered" guarantee for that specific nesting case.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDescribeStack = getDescribeStack;
+exports.ensureDescribeTracked = ensureDescribeTracked;
+exports.__resetDescribeStackForTests = __resetDescribeStackForTests;
+let patched = false;
+const stack = [];
+function getDescribeStack() {
+    return [...stack];
+}
+function wrapBlock(original, name, fn, ...rest) {
+    return original(name, (...args) => {
+        stack.push(name);
+        try {
+            return fn(...args);
+        }
+        finally {
+            stack.pop();
+        }
+    }, ...rest);
+}
+function ensureDescribeTracked() {
+    if (patched)
+        return;
+    const g = globalThis;
+    const original = g.describe;
+    if (typeof original !== 'function')
+        return;
+    patched = true;
+    const tracked = ((name, fn, ...rest) => wrapBlock(original, name, fn, ...rest));
+    // Copy through any other static properties (e.g. `.each`) unpatched first
+    // -- best-effort tracking is better than throwing away functionality --
+    // then override `.only`/`.skip` with tracked versions so they aren't
+    // clobbered by the copy.
+    Object.assign(tracked, original);
+    if (typeof original.only === 'function') {
+        tracked.only = (name, fn, ...rest) => wrapBlock(original.only, name, fn, ...rest);
+    }
+    if (typeof original.skip === 'function') {
+        tracked.skip = (name, fn, ...rest) => wrapBlock(original.skip, name, fn, ...rest);
+    }
+    g.describe = tracked;
+}
+/** Test-only: reset patch state and stack between test cases. */
+function __resetDescribeStackForTests() {
+    patched = false;
+    stack.length = 0;
+}

package/dist/httpClient.d.ts

@@ -0,0 +1,12 @@
+export interface HttpResult {
+    status: number;
+    body: unknown;
+}
+export interface ImportAttachment {
+    caseKey: string;
+    filename: string;
+    contentType: string;
+    data: string;
+}
+export declare function postImport(url: string, project: string, token: string | undefined, report: string, attachments: ImportAttachment[]): Promise<HttpResult>;
+export declare function getCases(url: string, project: string, token: string | undefined): Promise<HttpResult>;

package/dist/httpClient.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postImport = postImport;
+exports.getCases = getCases;
+function joinUrl(base, pathname) {
+    return `${base.replace(/\/$/, '')}${pathname}`;
+}
+function authHeaders(token) {
+    return token ? { Authorization: `Bearer ${token}` } : {};
+}
+async function parseBody(res) {
+    const text = await res.text();
+    if (!text)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+async function postImport(url, project, token, report, attachments) {
+    const res = await fetch(joinUrl(url, `/api/v1/projects/${encodeURIComponent(project)}/imports`), {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...authHeaders(token) },
+        body: JSON.stringify({ format: 'junit-xml', report, attachments }),
+    });
+    return { status: res.status, body: await parseBody(res) };
+}
+async function getCases(url, project, token) {
+    const res = await fetch(joinUrl(url, `/api/v1/projects/${encodeURIComponent(project)}/cases`), {
+        headers: authHeaders(token),
+    });
+    return { status: res.status, body: await parseBody(res) };
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { testpulse } from './testpulse';
+export type { TestpulseOptions } from './testpulse';
+export { testpulseAttach } from './testpulseAttach';
+export type { TestpulseAttachOptions } from './testpulseAttach';
+export { setScratchDir } from './scratchDir';
+export { default } from './reporter';

package/dist/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.setScratchDir = exports.testpulseAttach = exports.testpulse = void 0;
+var testpulse_1 = require("./testpulse");
+Object.defineProperty(exports, "testpulse", { enumerable: true, get: function () { return testpulse_1.testpulse; } });
+var testpulseAttach_1 = require("./testpulseAttach");
+Object.defineProperty(exports, "testpulseAttach", { enumerable: true, get: function () { return testpulseAttach_1.testpulseAttach; } });
+var scratchDir_1 = require("./scratchDir");
+Object.defineProperty(exports, "setScratchDir", { enumerable: true, get: function () { return scratchDir_1.setScratchDir; } });
+var reporter_1 = require("./reporter");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(reporter_1).default; } });

package/dist/jestState.d.ts

@@ -0,0 +1,6 @@
+export type TestFn = (...args: unknown[]) => unknown;
+export type TestRegistrar = (name: string, fn: TestFn, timeout?: number) => void;
+export declare function getGlobalTestRegistrar(): TestRegistrar;
+/** Reconstructs Jest's own fullName from an AssertionResult's ancestorTitles/title -- the same value `currentTestName` holds while the test is running. */
+export declare function reconstructFullName(ancestorTitles: string[], title: string): string;
+export declare function getCurrentTestName(): string;

package/dist/jestState.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGlobalTestRegistrar = getGlobalTestRegistrar;
+exports.reconstructFullName = reconstructFullName;
+exports.getCurrentTestName = getCurrentTestName;
+function getGlobalTestRegistrar() {
+    const g = globalThis;
+    const registrar = (g.test ?? g.it);
+    if (typeof registrar !== 'function') {
+        throw new Error('testpulse-jest: no global test()/it() found -- testpulse() must be called from within a Jest test file');
+    }
+    return registrar;
+}
+/** Reconstructs Jest's own fullName from an AssertionResult's ancestorTitles/title -- the same value `currentTestName` holds while the test is running. */
+function reconstructFullName(ancestorTitles, title) {
+    return [...ancestorTitles, title].join(' ').trim();
+}
+function getCurrentTestName() {
+    const g = globalThis;
+    const name = g.expect?.getState?.()?.currentTestName;
+    if (typeof name !== 'string') {
+        throw new Error('testpulse-jest: unable to resolve the current test name via expect.getState().currentTestName -- is this running inside a Jest test?');
+    }
+    return name;
+}

package/dist/junitTestCaseProperties.d.ts

@@ -0,0 +1,14 @@
+interface JestJunitTestCase {
+    title: string;
+    ancestorTitles: string[];
+}
+type JunitProperties = Record<string, string>;
+/**
+ * jest-junit's `testCasePropertiesFile` hook. Called synchronously, once
+ * per testcase, while jest-junit builds its <properties> block -- reads
+ * the scratch dir's case-key sidecars (already flushed to disk by the
+ * time jest-junit's own onRunComplete runs) rather than anything on `tc`
+ * itself.
+ */
+declare function getTestCaseProperties(tc: JestJunitTestCase): JunitProperties;
+export = getTestCaseProperties;

package/dist/junitTestCaseProperties.js

@@ -0,0 +1,26 @@
+"use strict";
+const scratchDir_1 = require("./scratchDir");
+const caseStore_1 = require("./caseStore");
+const jestState_1 = require("./jestState");
+/**
+ * jest-junit's `testCasePropertiesFile` hook. Called synchronously, once
+ * per testcase, while jest-junit builds its <properties> block -- reads
+ * the scratch dir's case-key sidecars (already flushed to disk by the
+ * time jest-junit's own onRunComplete runs) rather than anything on `tc`
+ * itself.
+ */
+function getTestCaseProperties(tc) {
+    const fullName = (0, jestState_1.reconstructFullName)(tc.ancestorTitles ?? [], tc.title);
+    const metadata = (0, caseStore_1.readCaseMetadata)((0, scratchDir_1.getScratchDir)(), fullName);
+    if (!metadata)
+        return {};
+    const properties = { testpulse_case_key: metadata.caseKey };
+    if (metadata.platform)
+        properties.testpulse_platform = metadata.platform;
+    if (metadata.version)
+        properties.testpulse_version = metadata.version;
+    if (metadata.tags && metadata.tags.length > 0)
+        properties.testpulse_tags = metadata.tags.join(',');
+    return properties;
+}
+module.exports = getTestCaseProperties;

package/dist/reporter.d.ts

@@ -0,0 +1,23 @@
+import { ReporterOptions } from './config';
+export default class TestPulseReporter {
+    private readonly config;
+    constructor(_globalConfig: unknown, options?: ReporterOptions);
+    /**
+     * Runs exactly once, in the main process, before any worker starts
+     * executing tests -- the correct place to clear stale scratch-dir
+     * contents from a prior (possibly crashed) run. `testpulse()`/
+     * `testpulseAttach()` run inside per-test-file worker processes and
+     * cannot coordinate a "first call wins" check with each other; see
+     * design.md for why that approach was rejected.
+     */
+    onRunStart(): void;
+    onRunComplete(_contexts?: unknown, results?: {
+        startTime?: number;
+    }): Promise<void>;
+    private readJunitReport;
+    private buildAttachments;
+    /** Returns whether the submission itself succeeded (a run was created), independent of failOnUnmatched's effect on exit code. */
+    private handleSubmissionResult;
+    private runDryRun;
+    private cleanup;
+}

package/dist/reporter.js

@@ -0,0 +1,175 @@
+"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 });
+const fs = __importStar(require("fs"));
+const scratchDir_1 = require("./scratchDir");
+const caseStore_1 = require("./caseStore");
+const attachmentStore_1 = require("./attachmentStore");
+const config_1 = require("./config");
+const httpClient_1 = require("./httpClient");
+class TestPulseReporter {
+    constructor(_globalConfig, options = {}) {
+        this.config = (0, config_1.resolveConfig)(options);
+        (0, scratchDir_1.setScratchDir)(this.config.scratchDir);
+    }
+    /**
+     * Runs exactly once, in the main process, before any worker starts
+     * executing tests -- the correct place to clear stale scratch-dir
+     * contents from a prior (possibly crashed) run. `testpulse()`/
+     * `testpulseAttach()` run inside per-test-file worker processes and
+     * cannot coordinate a "first call wins" check with each other; see
+     * design.md for why that approach was rejected.
+     */
+    onRunStart() {
+        fs.rmSync(this.config.scratchDir, { recursive: true, force: true });
+        fs.mkdirSync((0, scratchDir_1.casesDir)(this.config.scratchDir), { recursive: true });
+        fs.mkdirSync((0, scratchDir_1.attachmentsDir)(this.config.scratchDir), { recursive: true });
+    }
+    async onRunComplete(_contexts, results) {
+        const config = this.config;
+        if (config.dryRun) {
+            await this.runDryRun(config);
+            return;
+        }
+        if (!config.url || !config.project) {
+            throw new Error('testpulse-jest: no url/project configured (TESTPULSE_URL/TESTPULSE_PROJECT env vars, or `url`/`project` reporter options in jest.config.js).');
+        }
+        const junitReport = this.readJunitReport(config.junitFile, results?.startTime);
+        const attachments = this.buildAttachments(config.scratchDir);
+        let status;
+        let body;
+        try {
+            ({ status, body } = await (0, httpClient_1.postImport)(config.url, config.project, config.token, junitReport, attachments));
+        }
+        catch (err) {
+            // eslint-disable-next-line no-console
+            console.error(`testpulse-jest: submission request failed: ${err.message}`);
+            process.exitCode = 1;
+            return;
+        }
+        const succeeded = this.handleSubmissionResult(status, body, config);
+        // Only clean up on a successful submission (201/207) -- a failed one
+        // leaves the scratch dir in place (subject to keepScratchDir's normal
+        // meaning) so its contents are actually inspectable when debugging the
+        // one situation you'd most want them: a failure.
+        if (succeeded)
+            this.cleanup(config);
+    }
+    readJunitReport(junitFile, runStartTime) {
+        if (!fs.existsSync(junitFile)) {
+            throw new Error(`testpulse-jest: no JUnit report found at "${junitFile}". Check that "testpulse-jest" is listed AFTER ` +
+                '"jest-junit" in your jest.config.js "reporters" array, and that jest-junit is configured to write to this path.');
+        }
+        // A reporters-ordering mistake ("testpulse-jest" before "jest-junit")
+        // combined with a pre-existing junit.xml from a prior run (a common,
+        // ordinary situation -- local dev re-running jest in the same
+        // directory, a reused CI workspace) would otherwise mean this reporter
+        // reads and silently submits the OLD report, with no error at all,
+        // even though the current run's real results are different. Comparing
+        // the file's mtime against this run's own startTime catches that.
+        if (typeof runStartTime === 'number') {
+            const mtimeMs = fs.statSync(junitFile).mtimeMs;
+            if (mtimeMs < runStartTime) {
+                throw new Error(`testpulse-jest: the JUnit report at "${junitFile}" is older than this test run -- it wasn't ` +
+                    'refreshed by jest-junit before this reporter read it. Check that "testpulse-jest" is listed AFTER ' +
+                    '"jest-junit" in your jest.config.js "reporters" array. Refusing to submit a stale report.');
+            }
+        }
+        return fs.readFileSync(junitFile, 'utf8');
+    }
+    buildAttachments(scratchDir) {
+        const caseKeyByFullName = new Map((0, caseStore_1.readAllCaseMetadata)(scratchDir).map((c) => [c.fullName, c.caseKey]));
+        const attachments = [];
+        for (const attachment of (0, attachmentStore_1.readAllAttachments)(scratchDir)) {
+            const caseKey = caseKeyByFullName.get(attachment.fullName);
+            if (!caseKey)
+                continue;
+            attachments.push({
+                caseKey,
+                filename: attachment.filename,
+                contentType: attachment.contentType,
+                data: fs.readFileSync(attachment.dataPath).toString('base64'),
+            });
+        }
+        return attachments;
+    }
+    /** Returns whether the submission itself succeeded (a run was created), independent of failOnUnmatched's effect on exit code. */
+    handleSubmissionResult(status, body, config) {
+        if (status === 201) {
+            const run = body;
+            // eslint-disable-next-line no-console
+            console.log(`testpulse-jest: submitted successfully (run ${run?.id ?? '?'})`);
+            return true;
+        }
+        if (status === 207) {
+            const info = body;
+            const unmatchedKeys = (info?.unmatched ?? []).map((u) => u.caseKey);
+            // eslint-disable-next-line no-console
+            console.warn(`testpulse-jest: ${unmatchedKeys.length} case(s) unmatched: ${unmatchedKeys.join(', ')}. ` +
+                'Set failOnUnmatched (or TESTPULSE_FAIL_ON_UNMATCHED) to make this a hard failure.');
+            if (config.failOnUnmatched)
+                process.exitCode = 1;
+            return true;
+        }
+        // eslint-disable-next-line no-console
+        console.error(`testpulse-jest: submission failed (status ${status}): ${JSON.stringify(body)}`);
+        process.exitCode = 1;
+        return false;
+    }
+    async runDryRun(config) {
+        if (!config.url || !config.project) {
+            throw new Error('testpulse-jest: dryRun requires url/project to be configured (TESTPULSE_URL/TESTPULSE_PROJECT env vars, or `url`/`project` reporter options).');
+        }
+        const cases = (0, caseStore_1.readAllCaseMetadata)(config.scratchDir);
+        const { status, body } = await (0, httpClient_1.getCases)(config.url, config.project, config.token);
+        if (status >= 300) {
+            // eslint-disable-next-line no-console
+            console.error(`testpulse-jest: dry run failed to fetch cases (status ${status})`);
+            return;
+        }
+        const existingKeys = new Set((body ?? []).map((c) => c.key));
+        const unmatched = cases.filter((c) => !existingKeys.has(c.caseKey));
+        const matchedCount = cases.length - unmatched.length;
+        // eslint-disable-next-line no-console
+        console.log(`testpulse-jest: dry run -- ${matchedCount} would match, ${unmatched.length} would not` +
+            (unmatched.length > 0 ? `: ${unmatched.map((c) => c.caseKey).join(', ')}` : ''));
+    }
+    cleanup(config) {
+        if (config.keepScratchDir)
+            return;
+        fs.rmSync(config.scratchDir, { recursive: true, force: true });
+    }
+}
+exports.default = TestPulseReporter;

package/dist/scratchDir.d.ts

@@ -0,0 +1,16 @@
+export declare const DEFAULT_SCRATCH_DIR = ".testpulse";
+/** Overrides the scratch directory path. Exposed for the reporter's config resolution. */
+export declare function setScratchDir(dir: string): void;
+export declare function getScratchDir(): string;
+export declare function casesDir(base?: string): string;
+export declare function attachmentsDir(base?: string): string;
+/**
+ * Sidecar filenames are a hash of the fullName, never the fullName itself
+ * or any derivative of it used as a path component -- Jest test titles are
+ * fully user-controlled strings with no character restrictions, so a name
+ * containing `/` or `..` must not be able to influence where the sidecar
+ * is written.
+ */
+export declare function hashFullName(fullName: string): string;
+/** Reset the module-level override -- test-only helper. */
+export declare function __resetScratchDirForTests(): void;

package/dist/scratchDir.js

@@ -0,0 +1,73 @@
+"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.DEFAULT_SCRATCH_DIR = void 0;
+exports.setScratchDir = setScratchDir;
+exports.getScratchDir = getScratchDir;
+exports.casesDir = casesDir;
+exports.attachmentsDir = attachmentsDir;
+exports.hashFullName = hashFullName;
+exports.__resetScratchDirForTests = __resetScratchDirForTests;
+const crypto = __importStar(require("crypto"));
+const path = __importStar(require("path"));
+exports.DEFAULT_SCRATCH_DIR = '.testpulse';
+let scratchDir = exports.DEFAULT_SCRATCH_DIR;
+/** Overrides the scratch directory path. Exposed for the reporter's config resolution. */
+function setScratchDir(dir) {
+    scratchDir = dir;
+}
+function getScratchDir() {
+    return scratchDir;
+}
+function casesDir(base = scratchDir) {
+    return path.join(base, 'cases');
+}
+function attachmentsDir(base = scratchDir) {
+    return path.join(base, 'attachments');
+}
+/**
+ * Sidecar filenames are a hash of the fullName, never the fullName itself
+ * or any derivative of it used as a path component -- Jest test titles are
+ * fully user-controlled strings with no character restrictions, so a name
+ * containing `/` or `..` must not be able to influence where the sidecar
+ * is written.
+ */
+function hashFullName(fullName) {
+    return crypto.createHash('sha256').update(fullName, 'utf8').digest('hex');
+}
+/** Reset the module-level override -- test-only helper. */
+function __resetScratchDirForTests() {
+    scratchDir = exports.DEFAULT_SCRATCH_DIR;
+}

package/dist/testpulse.d.ts

@@ -0,0 +1,21 @@
+import { CaseOptions } from './caseStore';
+import { TestFn } from './jestState';
+export type TestpulseOptions = CaseOptions;
+/**
+ * Wraps `test`/`it`, tagging the test with a TestPulse case key without
+ * altering its visible title -- the title/AssertionResult Jest itself
+ * produces is identical to an unwrapped call with the same name.
+ *
+ * Writes the case-key sidecar TWICE, deliberately: once synchronously at
+ * registration time (using the tracked describe-nesting stack, so a test
+ * that never actually runs -- filtered out by `-t`, shadowed by a sibling
+ * `.only`, cut short by `--bail`, a partial watch-mode run -- still gets
+ * linked, rather than silently losing its case key and showing up as a
+ * spurious "unmatched" entry) and again at execution time if the test
+ * body does run (using `expect.getState().currentTestName`, which is
+ * authoritative and correct even in the one case the tracked stack can't
+ * see: `describe.each` -- see describeStack.ts). The execution-time write
+ * is a same-data no-op in the common case, and a correcting overwrite in
+ * that one edge case.
+ */
+export declare function testpulse(caseKey: string, opts?: TestpulseOptions): (name: string, fn: TestFn, timeout?: number) => void;

package/dist/testpulse.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testpulse = testpulse;
+const scratchDir_1 = require("./scratchDir");
+const caseStore_1 = require("./caseStore");
+const jestState_1 = require("./jestState");
+const describeStack_1 = require("./describeStack");
+// Patches global describe() at MODULE LOAD time (a side effect of
+// `require('testpulse-jest')`), not lazily on first testpulse() call --
+// describe blocks run synchronously top-down during Jest's collection
+// phase, so by the time any nested testpulse() call could trigger a lazy
+// patch, the outermost describe() in the file would already have run
+// unpatched. Real consumers import this package before defining any
+// describe()/test() blocks, so module-load-time patching is early enough.
+(0, describeStack_1.ensureDescribeTracked)();
+/**
+ * Wraps `test`/`it`, tagging the test with a TestPulse case key without
+ * altering its visible title -- the title/AssertionResult Jest itself
+ * produces is identical to an unwrapped call with the same name.
+ *
+ * Writes the case-key sidecar TWICE, deliberately: once synchronously at
+ * registration time (using the tracked describe-nesting stack, so a test
+ * that never actually runs -- filtered out by `-t`, shadowed by a sibling
+ * `.only`, cut short by `--bail`, a partial watch-mode run -- still gets
+ * linked, rather than silently losing its case key and showing up as a
+ * spurious "unmatched" entry) and again at execution time if the test
+ * body does run (using `expect.getState().currentTestName`, which is
+ * authoritative and correct even in the one case the tracked stack can't
+ * see: `describe.each` -- see describeStack.ts). The execution-time write
+ * is a same-data no-op in the common case, and a correcting overwrite in
+ * that one edge case.
+ */
+function testpulse(caseKey, opts = {}) {
+    if (typeof caseKey !== 'string' || caseKey.length === 0) {
+        throw new Error(`testpulse-jest: testpulse() requires a non-empty case key string, got: ${JSON.stringify(caseKey)}`);
+    }
+    return function registerTest(name, fn, timeout) {
+        (0, caseStore_1.writeCaseMetadata)((0, scratchDir_1.getScratchDir)(), (0, jestState_1.reconstructFullName)((0, describeStack_1.getDescribeStack)(), name), caseKey, opts);
+        const registrar = (0, jestState_1.getGlobalTestRegistrar)();
+        registrar(name, async (...args) => {
+            (0, caseStore_1.writeCaseMetadata)((0, scratchDir_1.getScratchDir)(), (0, jestState_1.getCurrentTestName)(), caseKey, opts);
+            return fn(...args);
+        }, timeout);
+    };
+}

package/dist/testpulseAttach.d.ts

@@ -0,0 +1,11 @@
+export interface TestpulseAttachOptions {
+    filename: string;
+    contentType: string;
+}
+/**
+ * Registers an attachment for the currently-running testpulse()-wrapped
+ * test. Content-type validation happens synchronously (before any I/O),
+ * so an invalid content type throws immediately even though the overall
+ * function returns a Promise for the (potentially async) file read.
+ */
+export declare function testpulseAttach(bufferOrPath: Buffer | string, opts: TestpulseAttachOptions): Promise<void>;

package/dist/testpulseAttach.js

@@ -0,0 +1,65 @@
+"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.testpulseAttach = testpulseAttach;
+const fs = __importStar(require("fs"));
+const scratchDir_1 = require("./scratchDir");
+const caseStore_1 = require("./caseStore");
+const attachmentStore_1 = require("./attachmentStore");
+const jestState_1 = require("./jestState");
+/**
+ * Registers an attachment for the currently-running testpulse()-wrapped
+ * test. Content-type validation happens synchronously (before any I/O),
+ * so an invalid content type throws immediately even though the overall
+ * function returns a Promise for the (potentially async) file read.
+ */
+function testpulseAttach(bufferOrPath, opts) {
+    if (!(0, attachmentStore_1.isSupportedContentType)(opts.contentType)) {
+        throw new Error(`testpulse-jest: testpulseAttach() only supports ${attachmentStore_1.SUPPORTED_CONTENT_TYPES.join(', ')}, got: ${opts.contentType}`);
+    }
+    return attach(bufferOrPath, opts);
+}
+async function attach(bufferOrPath, opts) {
+    const scratchDir = (0, scratchDir_1.getScratchDir)();
+    const fullName = (0, jestState_1.getCurrentTestName)();
+    const existingCase = (0, caseStore_1.readCaseMetadata)(scratchDir, fullName);
+    if (!existingCase) {
+        // eslint-disable-next-line no-console
+        console.warn(`testpulse-jest: testpulseAttach() called from "${fullName}", which has no testpulse() case key -- dropping the attachment.`);
+        return;
+    }
+    const data = Buffer.isBuffer(bufferOrPath) ? bufferOrPath : await fs.promises.readFile(bufferOrPath);
+    (0, attachmentStore_1.writeAttachment)(scratchDir, fullName, data, opts.filename, opts.contentType);
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "testpulse-jest",
+  "version": "0.1.0",
+  "description": "Jest reporter + jest-junit companion for reporting test results into TestPulse",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Barayo/testpulse-jest.git"
+  },
+  "homepage": "https://github.com/Barayo/testpulse-jest#readme",
+  "bugs": "https://github.com/Barayo/testpulse-jest/issues",
+  "keywords": ["jest", "jest-reporter", "testpulse", "junit", "test-management"],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js"
+    },
+    "./junitTestCaseProperties": {
+      "types": "./dist/junitTestCaseProperties.d.ts",
+      "require": "./dist/junitTestCaseProperties.js"
+    }
+  },
+  "files": ["dist"],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "test": "jest --selectProjects unit",
+    "test:e2e": "npm run build && jest --selectProjects e2e",
+    "test:all": "npm run build && jest",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "peerDependencies": {
+    "jest-junit": ">=11"
+  },
+  "devDependencies": {
+    "@semantic-release/exec": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^20.17.9",
+    "jest": "^29.7.0",
+    "jest-junit": "^16.0.0",
+    "msw": "^2.6.6",
+    "semantic-release": "^24.2.0",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.7.2"
+  }
+}