@starci/jest-preset 2.3.6 → 2.4.0

package/dist/event-bus.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordingEventBus = recordingEventBus;
+/**
+ * `recordingEventBus()` -- an `EventBus` double that records what a domain service publishes, so a spec asserts on `bus.events`.
+ *
+ * `publish(event, tx)` records the event with the manager it was written through. `events` is what the outbox would hold: one
+ * event per (event name, event id), like the real unique key, so a duplicate publication keeps one. `writes` is every call, duplicates
+ * included, and `entries` adds `inTransaction`: whether `tx` was the view a `fakeTransaction` body received, so a spec proves an event
+ * is published in the transaction of the change that caused it. The name of an event is the static `eventName` of its class.
+ *
+ * The read side is scripted: `setPendingRetries(count)` sets what `pendingRetries(eventClass)` answers, `deadLetters(eventClass)`
+ * returns what `queueDeadLetters(...letters)` filled, `requeue(id)` records the id, and `failNext(operation, error)` makes the next
+ * call of that operation reject once, so a spec drives the failure path.
+ */
+const entity_manager_ts_1 = require("./entity-manager.js");
+/** The name of an event: the static `eventName` of its class. */
+const nameOf = (event) => {
+    const eventClass = event.constructor;
+    return typeof eventClass === "function" && "eventName" in eventClass ? eventClass.eventName : undefined;
+};
+/** The event bus double. */
+function recordingEventBus() {
+    const written = [];
+    const letters = [];
+    const requeued = [];
+    const failures = new Map();
+    let pending = 0;
+    const failIfScripted = (operation) => {
+        const error = failures.get(operation);
+        if (error === undefined)
+            return;
+        failures.delete(operation);
+        throw error;
+    };
+    return {
+        async publish(event, tx) {
+            failIfScripted("publish");
+            written.push({ event, tx, inTransaction: (0, entity_manager_ts_1.isTransactionManager)(tx) });
+        },
+        async pendingRetries() {
+            failIfScripted("pendingRetries");
+            return pending;
+        },
+        async deadLetters(eventClass) {
+            failIfScripted("deadLetters");
+            return letters.filter((letter) => letter.eventName === eventClass.eventName);
+        },
+        async requeue(id) {
+            failIfScripted("requeue");
+            requeued.push(id);
+        },
+        /** The events the outbox would hold: the first publication of each (event name, event id). */
+        get events() {
+            const seen = new Set();
+            return written
+                .filter(({ event }) => {
+                const key = `${String(nameOf(event))}\u0000${event.eventId}`;
+                if (seen.has(key))
+                    return false;
+                seen.add(key);
+                return true;
+            })
+                .map(({ event }) => event);
+        },
+        /** Every publication, in order: `{ event, tx, inTransaction }`. */
+        get entries() {
+            return [...written];
+        },
+        /** Every event published, duplicates included. */
+        get writes() {
+            return written.map(({ event }) => event);
+        },
+        /** True when something was published and every publication went through a transaction manager. */
+        get allInTransaction() {
+            return written.length > 0 && written.every((entry) => entry.inTransaction);
+        },
+        /** The stored events of one class. */
+        eventsOf(eventClass) {
+            return this.events.filter((event) => nameOf(event) === eventClass.eventName);
+        },
+        /** Sets the answer of `pendingRetries`. */
+        setPendingRetries(count) {
+            pending = count;
+        },
+        /** Adds dead letters `deadLetters` hands out. */
+        queueDeadLetters(...items) {
+            letters.push(...items);
+        },
+        /** The ids passed to `requeue`, in order. */
+        get requeued() {
+            return [...requeued];
+        },
+        /** Makes the next call of `operation` reject with `error`, once. */
+        failNext(operation, error) {
+            failures.set(operation, error);
+        },
+        clear() {
+            written.length = 0;
+            letters.length = 0;
+            requeued.length = 0;
+            pending = 0;
+            failures.clear();
+        },
+    };
+}

package/dist/ids.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `fakeIds()` -- the test double for the platform ids port (`{ next(): string }`; the production adapter is
+ * `randomUUID()` behind the port). Ids are deterministic and UUID-shaped, so a spec can assert on the exact persisted id:
+ * the first is `00000000-0000-4000-8000-000000000001`, the second `...0002`, and so on. A `prefix` (1 to 8 hex digits)
+ * changes the leading group so two generators in one spec never collide.
+ */
+/** The platform ids port a spec injects `fakeIds()` for: `{ next(): string }`. */
+export declare class FakeIds {
+    private readonly _prefix;
+    private _issued;
+    /** @param prefix - 1 to 8 hex digits for the first group; default "00000000". */
+    constructor(prefix?: string);
+    /** The next deterministic UUID-shaped id. */
+    next(): string;
+    /** Every id handed out so far, in order. */
+    get issued(): ReadonlyArray<string>;
+    /** Starts the sequence over. */
+    reset(): void;
+}
+/** A deterministic id generator: `00000000-0000-4000-8000-000000000001`, `...0002`, ... */
+export declare function fakeIds(prefix?: string): FakeIds;

package/dist/ids.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * `fakeIds()` -- the test double for the platform ids port (`{ next(): string }`; the production adapter is
+ * `randomUUID()` behind the port). Ids are deterministic and UUID-shaped, so a spec can assert on the exact persisted id:
+ * the first is `00000000-0000-4000-8000-000000000001`, the second `...0002`, and so on. A `prefix` (1 to 8 hex digits)
+ * changes the leading group so two generators in one spec never collide.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FakeIds = void 0;
+exports.fakeIds = fakeIds;
+/** The platform ids port a spec injects `fakeIds()` for: `{ next(): string }`. */
+class FakeIds {
+    _prefix;
+    _issued;
+    /** @param prefix - 1 to 8 hex digits for the first group; default "00000000". */
+    constructor(prefix = "00000000") {
+        if (!/^[0-9a-f]{1,8}$/i.test(prefix))
+            throw new Error("fakeIds: the prefix is 1 to 8 hex digits");
+        this._prefix = prefix.padStart(8, "0").toLowerCase();
+        this._issued = [];
+    }
+    /** The next deterministic UUID-shaped id. */
+    next() {
+        const n = String(this._issued.length + 1).padStart(12, "0");
+        const id = `${this._prefix}-0000-4000-8000-${n}`;
+        this._issued.push(id);
+        return id;
+    }
+    /** Every id handed out so far, in order. */
+    get issued() {
+        return [...this._issued];
+    }
+    /** Starts the sequence over. */
+    reset() {
+        this._issued = [];
+    }
+}
+exports.FakeIds = FakeIds;
+/** A deterministic id generator: `00000000-0000-4000-8000-000000000001`, `...0002`, ... */
+function fakeIds(prefix) {
+    return new FakeIds(prefix);
+}

package/dist/inbox.d.ts

@@ -0,0 +1,65 @@
+/** One claim or release of a delivery. */
+export interface InboxEntry {
+    readonly source: string;
+    readonly eventId: string;
+}
+/** The inbox operations `failNext` can make reject. */
+export type InboxOperation = "claim" | "release" | "runClient" | "sweepClients";
+/** The client operation namespace, exact key and JSON request whose outcome the inbox stores. */
+export interface InboxClientOperation {
+    readonly principalId: string;
+    readonly operation: string;
+    readonly idempotencyKey: string;
+    readonly request: unknown;
+}
+/** A client claim with the manager passed by its caller. */
+export interface InboxClientEntry extends InboxEntry {
+    readonly tx: unknown;
+    readonly inTransaction: boolean;
+}
+/** One retention sweep with the cutoff instant and manager passed by its caller. */
+export interface InboxSweep {
+    readonly cutoff: Date;
+    readonly tx: unknown;
+    readonly inTransaction: boolean;
+}
+/** An `Inbox` double with the behaviour of the real claim. */
+export interface FakeInbox {
+    /** True for the first claim of a (source, eventId) pair, false for every later one until it is released. */
+    claim(source: string, eventId: string): Promise<boolean>;
+    /** Gives an ordinary delivery claim back while preserving client receipts and their outcomes. */
+    release(source: string, eventId: string): Promise<void>;
+    /** Runs once for the client namespace and key, replays the JSON outcome and refuses a different body. */
+    runClient<T>(request: InboxClientOperation, tx: unknown, effect: () => Promise<T>): Promise<T>;
+    /** Deletes at most one batch of completed client claims older than the cutoff. */
+    sweepClients(cutoff: Date, tx: unknown): Promise<number>;
+    /** Marks a pair as already claimed (a redelivery). */
+    seen(source: string, eventId: string): void;
+    /** Makes the next call of `operation` reject with `error`, once. */
+    failNext(operation: InboxOperation, error: Error): void;
+    /** Every claim, in order, duplicates included. */
+    readonly claims: ReadonlyArray<InboxEntry>;
+    /** The pairs held now: claimed and not released. */
+    readonly claimed: ReadonlyArray<InboxEntry>;
+    /** Every release, in order. */
+    readonly released: ReadonlyArray<InboxEntry>;
+    /** Every client claim with its manager; this double records transaction ownership, not database commit semantics. */
+    readonly clientEntries: ReadonlyArray<InboxClientEntry>;
+    /** Every sweep attempt with its cutoff and transaction, including a scripted failure. */
+    readonly sweeps: ReadonlyArray<InboxSweep>;
+    clear(): void;
+}
+/**
+ * `fakeInbox(clock?)` records delivery and client claims, so a spec asserts deduplication and the transaction passed by
+ * its service. Client calls replay JSON outcomes; `clock` gives retention tests a driven claim timestamp.
+ *
+ * `claim(source, eventId)` answers `true` for the first call of a (source, eventId) pair and `false` for every later one, like the
+ * real unique key; `release(source, eventId)` gives an ordinary delivery claim back while preserving client outcomes.
+ * `claims` is every claim in order, `claimed` the pairs that are held now, `released` every release, `seen(source, eventId)` marks a
+ * pair as already delivered (a redelivery), and `failNext(operation, error)` makes the next call of that operation reject once, so
+ * a spec drives the failure path.
+ */
+/** The inbox double. Pass a driven clock to test retention; omitted clocks stamp client claims at the Unix epoch. */
+export declare function fakeInbox(clock?: {
+    now(): Date;
+}): FakeInbox;

package/dist/inbox.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fakeInbox = fakeInbox;
+const node_util_1 = require("node:util");
+const entity_manager_ts_1 = require("./entity-manager.js");
+const CLIENT_SWEEP_BATCH = 500;
+/** The fake carries the production refusal code without depending on an application's error family. */
+const inboxError = (code) => Object.assign(new Error(code), { code });
+/** Clone JSON values directly so toJSON cannot change the request or the stored outcome. */
+const snapshot = (value, ancestors = new Set()) => {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return value;
+    if (typeof value === "number" && Number.isFinite(value))
+        return value === 0 ? 0 : value;
+    if (typeof value !== "object" || ancestors.has(value))
+        throw inboxError("IDEMPOTENCY_REQUEST_INVALID");
+    ancestors.add(value);
+    let result;
+    if (Array.isArray(value))
+        result = Array.from(value, (member) => snapshot(member, ancestors));
+    else {
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== Object.prototype && prototype !== null)
+            throw inboxError("IDEMPOTENCY_REQUEST_INVALID");
+        result = Object.fromEntries(Object.entries(value).map(([key, member]) => [key, snapshot(member, ancestors)]));
+    }
+    ancestors.delete(value);
+    return result;
+};
+/**
+ * `fakeInbox(clock?)` records delivery and client claims, so a spec asserts deduplication and the transaction passed by
+ * its service. Client calls replay JSON outcomes; `clock` gives retention tests a driven claim timestamp.
+ *
+ * `claim(source, eventId)` answers `true` for the first call of a (source, eventId) pair and `false` for every later one, like the
+ * real unique key; `release(source, eventId)` gives an ordinary delivery claim back while preserving client outcomes.
+ * `claims` is every claim in order, `claimed` the pairs that are held now, `released` every release, `seen(source, eventId)` marks a
+ * pair as already delivered (a redelivery), and `failNext(operation, error)` makes the next call of that operation reject once, so
+ * a spec drives the failure path.
+ */
+/** The inbox double. Pass a driven clock to test retention; omitted clocks stamp client claims at the Unix epoch. */
+function fakeInbox(clock) {
+    const held = new Set();
+    const claims = [];
+    const released = [];
+    const clients = new Map();
+    const clientEntries = [];
+    const sweeps = [];
+    const failures = new Map();
+    const keyOf = (source, eventId) => `${source}\u0000${eventId}`;
+    const failIfScripted = (operation) => {
+        const error = failures.get(operation);
+        if (error === undefined)
+            return;
+        failures.delete(operation);
+        throw error;
+    };
+    async function runClient(request, tx, effect) {
+        failIfScripted("runClient");
+        const { principalId, operation, idempotencyKey } = request;
+        if (!principalId.trim() || principalId.includes(":") || !operation.trim() || operation.includes(":")
+            || !idempotencyKey.trim() || idempotencyKey.length > 64) {
+            throw inboxError("IDEMPOTENCY_REQUEST_INVALID");
+        }
+        const source = `client:${principalId}:${operation}`;
+        const key = keyOf(source, idempotencyKey);
+        const body = snapshot(request.request);
+        claims.push({ source, eventId: idempotencyKey });
+        clientEntries.push({ source, eventId: idempotencyKey, tx, inTransaction: (0, entity_manager_ts_1.isTransactionManager)(tx) });
+        const previous = clients.get(key);
+        if (previous !== undefined) {
+            if (!(0, node_util_1.isDeepStrictEqual)(previous.request, body))
+                throw inboxError("IDEMPOTENCY_KEY_REUSED");
+            return snapshot(await previous.result);
+        }
+        if (held.has(key))
+            throw inboxError("IDEMPOTENCY_KEY_REUSED");
+        const entry = { request: body, claimedAt: clock === undefined ? new Date(0) : clock.now(), completed: false };
+        held.add(key);
+        clients.set(key, entry);
+        entry.result = Promise.resolve().then(effect).then((value) => {
+            let stored;
+            try {
+                stored = snapshot(value);
+            }
+            catch (cause) {
+                throw Object.assign(inboxError("INBOX_OUTCOME_INVALID"), { cause });
+            }
+            entry.completed = true;
+            return stored;
+        }).catch((error) => {
+            if (clients.get(key) === entry) {
+                clients.delete(key);
+                held.delete(key);
+            }
+            throw error;
+        });
+        return snapshot(await entry.result);
+    }
+    return {
+        async claim(source, eventId) {
+            failIfScripted("claim");
+            claims.push({ source, eventId });
+            const key = keyOf(source, eventId);
+            if (held.has(key))
+                return false;
+            held.add(key);
+            return true;
+        },
+        async release(source, eventId) {
+            failIfScripted("release");
+            released.push({ source, eventId });
+            const key = keyOf(source, eventId);
+            if (!clients.has(key))
+                held.delete(key);
+        },
+        runClient,
+        async sweepClients(cutoff, tx) {
+            sweeps.push({ cutoff: new Date(cutoff), tx, inTransaction: (0, entity_manager_ts_1.isTransactionManager)(tx) });
+            failIfScripted("sweepClients");
+            let swept = 0;
+            for (const [key, entry] of clients) {
+                if (swept === CLIENT_SWEEP_BATCH)
+                    break;
+                if (!entry.completed || entry.claimedAt >= cutoff)
+                    continue;
+                clients.delete(key);
+                held.delete(key);
+                swept += 1;
+            }
+            return swept;
+        },
+        /** Marks a pair as already claimed, so the next `claim` of it answers `false` (a redelivery). */
+        seen(source, eventId) {
+            held.add(keyOf(source, eventId));
+        },
+        /** Makes the next call of `operation` reject with `error`, once. */
+        failNext(operation, error) {
+            failures.set(operation, error);
+        },
+        /** Every `claim`, in order, duplicates included. */
+        get claims() {
+            return [...claims];
+        },
+        /** The pairs held now: claimed and not released. */
+        get claimed() {
+            return [...held].map((key) => {
+                const [source = "", eventId = ""] = key.split("\u0000");
+                return { source, eventId };
+            });
+        },
+        /** Every `release`, in order. */
+        get released() {
+            return [...released];
+        },
+        /** Every client claim, including repeats, with the domain transaction it used. */
+        get clientEntries() {
+            return [...clientEntries];
+        },
+        /** Every retention attempt with its cutoff and domain transaction, including a scripted failure. */
+        get sweeps() {
+            return [...sweeps];
+        },
+        clear() {
+            held.clear();
+            claims.length = 0;
+            released.length = 0;
+            failures.clear();
+            clients.clear();
+            clientEntries.length = 0;
+            sweeps.length = 0;
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,114 @@
+import type { Config } from "jest";
+import { mock, createMock } from "./mock.ts";
+import { mockEntityManager, fakeTransaction } from "./entity-manager.ts";
+import { FakeClock } from "./clock.ts";
+import { fakeCache } from "./cache.ts";
+import { fakeLock } from "./lock.ts";
+import { recordingEventBus } from "./event-bus.ts";
+import { recordingQueueOutbox } from "./queue.ts";
+import { fakeInbox } from "./inbox.ts";
+import { builder } from "./builders.ts";
+import { fakeIds, FakeIds } from "./ids.ts";
+export type { MockOf } from "./mock.ts";
+export type { MockEntityManager, FakeTransaction, EntityClass } from "./entity-manager.ts";
+export type { FakeCache } from "./cache.ts";
+export type { FakeLock } from "./lock.ts";
+export type { RecordingEventBus } from "./event-bus.ts";
+export type { RecordingQueueOutbox } from "./queue.ts";
+export type { FakeInbox } from "./inbox.ts";
+export type { RefusalReason } from "./matchers.ts";
+/** The coverage scope `starci app sync` renders from the slot manifest: the measured roots (a directory pattern per measured slot, a placeholder folder written as a star), the logic roles measured in them and the directories inside a root that are never measured (each ending in a double star). */
+export interface StarciCoverageScope {
+    readonly roots: readonly string[];
+    readonly roles: readonly string[];
+    readonly excludes: readonly string[];
+}
+export interface StarciJestOptions {
+    readonly coverage: StarciCoverageScope;
+}
+/** One project of the config (`unit`, `integration`, `e2e`, `contract`). */
+export type StarciJestProject = Exclude<NonNullable<Config["projects"]>[number], string>;
+/**
+ * The jest config `starciJestConfig` returns: jest's `Config` with its `projects` all objects, its `coverageReporters` allowing the path of a custom reporter (the lcov reporter of this preset is one)
+ * and its `coverageThreshold` keyed by glob only: jest accepts both, its own `Config` typing requires a `global` threshold and leaves out the reporter path.
+ */
+export type StarciJestConfig = Omit<Config, "projects" | "coverageReporters" | "coverageThreshold"> & {
+    projects: StarciJestProject[];
+    coverageThreshold?: Record<string, {
+        lines: number;
+        branches: number;
+        functions: number;
+        statements: number;
+    }>;
+    coverageReporters: Array<string | [string, Record<string, unknown>]>;
+};
+/**
+ * Coverage is measured where logic runs: every file `<name>.<role>.ts` of a LOGIC role (service, policy, projection, guard, mapper, client, ...)
+ * inside the roots the slot manifest marks `coverage: required` (the modules of the back end: domain, integrations, platform, projections).
+ * The features (handlers, resolvers, controllers, consumers, processors, steps, sagas, cli commands) are thin by rule (BE_FEATURE_THIN) and are
+ * never measured. The scope is NOT written here: `starci app sync` renders it from the manifest (scripts/hfs/coverage-scope.mjs) into the repository's
+ * jest.config.js as `starciJestConfig({ coverage: { roots, roles, excludes } })`, and the same derivation renders Sonar's
+ * `sonar.coverage.exclusions` and the Codecov paths and components, so the three can never disagree. Every measured file must reach 100 on every metric.
+ * The unit run also writes `coverage/lcov.info`: Sonar and Codecov import it.
+ */
+declare const COVERAGE_EXCLUDES: string[];
+/** The four metrics, each held at 100 per file. */
+declare const COVERAGE_THRESHOLD: Readonly<{
+    lines: 100;
+    branches: 100;
+    functions: 100;
+    statements: 100;
+}>;
+/** The glob one measured root stands for: every file of a logic role below it. */
+declare function rootGlob(root: string, roles: readonly string[]): string;
+/**
+ * jest's `collectCoverageFrom` of a coverage scope `{ roots, roles, excludes }`: the glob of every root, then the none directories inside a
+ * root (`excludes`, each a glob that ends in `**`) and the generated folders as negations.
+ */
+declare function collectCoverageFrom(coverage: StarciCoverageScope): string[];
+/**
+ * Sonar `sonar.exclusions`: specs, e2e specs, dist and coverage output are not analysed at all. The list lives in sonar-exclusions.ts, a
+ * require-free module whose built file @starci/hfs also ships (packages/hfs/runtime, scripts/hfs/sync-runtime.mjs), so `starci app scaffold`
+ * renders the same exclusions before any app dependency is installed.
+ */
+declare function sonarExclusions(): string;
+/** The unit project transpiles each file independently; helpers stay in tslib, source maps distinguish generated metadata, and type checks run separately. */
+declare const UNIT_COMPILER_OPTIONS: Readonly<{
+    isolatedModules: true;
+    importHelpers: true;
+    sourceMap: true;
+}>;
+/**
+ * The path aliases of a StarCi back end: the same three `paths` the managed `tsconfig.json` declares, so jest resolves what
+ * `tsc` resolves. They are part of the preset, not an option: a repository has no other alias.
+ */
+declare const MODULE_NAME_MAPPER: Readonly<Record<string, string>>;
+/** The test folders under `src/tests/` that a project other than `unit` owns (owner test layout 2026-09-30). */
+declare const TEST_KIND_FOLDERS: readonly string[];
+/**
+ * The whole jest config of a Nest repository: projects `unit` (colocated `<name>.spec.ts`), `integration`
+ * (`src/tests/integration/<capability>/<name>.integration-spec.ts`), `e2e` (`src/tests/e2e/<area>/<name>.e2e-spec.ts`) and
+ * `contract` (`src/tests/contract/<provider>/<name>.contract-spec.ts`). It takes ONE option, the coverage scope: the repository's `jest.config.js` is a managed file
+ * (R05), rendered by `starci app sync` as `module.exports = require("@starci/jest-preset").starciJestConfig({ coverage: { roots, roles, excludes } })`, the scope derived from the slot manifest.
+ *
+ * The managed scripts select one project each (`test` = unit, `test:integration`, `test:e2e`, `test:contract`); the
+ * contract project is never part of `test` or `test:e2e`, and a contract spec skips itself without sandbox config. The
+ * test tree compiles against `src/tests/tsconfig.json`, the nearest config of every file under `src/tests/`. The
+ * integration, e2e and contract projects share the world's `global-setup.ts`/`global-teardown.ts` (`src/tests/world/`) and
+ * run their spec files up to `min(--maxWorkers, slots)` at once, each in a worker process of its own bound to one data slot
+ * of the test world (`world-runner.js`; a slot's data is reset when a file boots, so no two files ever share a slot). A declared lite app instead runs its existing integration and contract specs without a world, on jest's stock runner. The unit project alone has a `setupFilesAfterEnv` (the Outcome matchers).
+ * Coverage is collected from the logic roles of the measured roots only (`coverage` option), with a per-file threshold of 100 on lines, branches, functions and
+ * statements: the `test` script runs the unit project with `--coverage`, fails below it and writes `coverage/lcov.info` for Sonar. It uses v8: istanbul instruments the helpers TypeScript emits (`__decorate`, `__param`, `__awaiter`, interop wrappers)
+ * as thousands of branches no spec can cover, while v8 measures the real source.
+ */
+/** The runner of the integration, e2e and contract projects (`world-runner.js`): every spec file in a worker process of its own. */
+declare const WORLD_RUNNER: string;
+/**
+ * True when the repository at `root` holds a file the coverage glob matches: jest refuses a threshold key that matches no covered file,
+ * and a back end may have no file of a measured root yet (no projection, no integration), so a root without files gets no key (its files,
+ * once added, are measured and held at 100 like every other).
+ */
+declare function hasCoverageSubjects(root: string, glob: string): boolean;
+/** The whole jest config: projects `unit`, `integration`, `e2e` and `contract`. It takes the coverage scope the managed repository config renders; without it it refuses. */
+declare function starciJestConfig(options: StarciJestOptions): StarciJestConfig;
+export { starciJestConfig, TEST_KIND_FOLDERS, MODULE_NAME_MAPPER, mock, createMock, mockEntityManager, fakeTransaction, FakeClock, fakeCache, fakeLock, recordingEventBus, recordingQueueOutbox, fakeInbox, builder, fakeIds, FakeIds, collectCoverageFrom, rootGlob, sonarExclusions, hasCoverageSubjects, COVERAGE_EXCLUDES, COVERAGE_THRESHOLD, UNIT_COMPILER_OPTIONS, WORLD_RUNNER, };