@gfdelarue/testkit 0.4.4 → 0.5.0

package/dist/toolchains/host-node-support.d.ts

@@ -1,3 +0,0 @@
-export declare const TESTKIT_SUPPORTED_HOST_NODE_RANGE = ">=22.15.0 <23.0.0 || >=24.14.1 <25.0.0";
-export declare const TESTKIT_SUPPORTED_HOST_NPM_RANGE = ">=11.6.0 <12.0.0";
-export declare function hostNodeIsSupported(version: unknown): boolean;

package/dist/toolchains/index.d.ts

@@ -1,114 +0,0 @@
-import type { NodeToolchainConfig } from "../config/authoring/index.js";
-export interface NormalizedNodeToolchainConfig {
-    cwd: string;
-    detect: "auto" | "off";
-    install: "download" | "require-host";
-    node: string | null;
-    npm: string | null;
-}
-export type NormalizedToolchainRegistry = Readonly<Partial<Record<string, NormalizedNodeToolchainConfig>>>;
-export interface NormalizedRuntimeToolchain extends NormalizedNodeToolchainConfig {
-    refName: string | null;
-    sourceLabel: string;
-}
-export interface ResolvedNodeToolchain {
-    binDir: string;
-    cwd: string;
-    fingerprint: string;
-    install: NormalizedNodeToolchainConfig["install"];
-    nodeExecutable: string;
-    nodeSource: string;
-    nodeSpec: string | null;
-    nodeVersion: string;
-    npmSource: string;
-    npmSpec: string | null;
-    npmVersion: string | null;
-    summary: string;
-    toolchainDir: string;
-}
-export interface RuntimeToolchainResolutionConfig {
-    cwd: string;
-    detect: NormalizedNodeToolchainConfig["detect"];
-    install: NormalizedNodeToolchainConfig["install"];
-    node: string | null;
-    npm: string | null;
-    refName: string | null;
-    sourceLabel: string;
-}
-export interface ToolchainRuntimeConfig {
-    name: string;
-    productDir: string;
-    testkit?: {
-        runtime?: {
-            toolchain?: RuntimeToolchainResolutionConfig | null;
-        } | null;
-    } | null;
-}
-export interface ToolchainReportConfig {
-    name: string;
-    runtimeLabel?: string | null;
-}
-export interface ToolchainResolvedReporter<Config extends ToolchainReportConfig = ToolchainReportConfig> {
-    toolchainResolved?: (config: Config, resolvedToolchain: ResolvedNodeToolchain) => unknown;
-}
-export type ToolchainEnvironment = Record<string, string | undefined>;
-export interface ToolchainDownloadResponse {
-    arrayBuffer: () => PromiseLike<ArrayBuffer>;
-    body?: AsyncIterable<Uint8Array> | null;
-    ok: boolean;
-    status: number;
-}
-export interface ToolchainFetchOptions {
-    signal?: AbortSignal;
-}
-export type ToolchainFetch = (downloadUrl: string, options?: ToolchainFetchOptions) => PromiseLike<ToolchainDownloadResponse>;
-export interface ToolchainCommandOptions {
-    cwd?: string;
-    env?: ToolchainEnvironment;
-    signal?: AbortSignal;
-    stdio?: "pipe";
-    timeoutMs?: number;
-    windowsHide?: boolean;
-}
-export interface ToolchainCommandResult {
-    stdout?: string | Uint8Array | null;
-}
-export interface PreparedManagedToolchainCommand {
-    readonly args: readonly string[];
-    readonly executable: string;
-}
-export type ToolchainCommandExecutor = (command: string, args: string[], options?: ToolchainCommandOptions) => PromiseLike<ToolchainCommandResult>;
-export interface ResolveConfiguredToolchainOptions {
-    commandExecutor?: ToolchainCommandExecutor;
-    fetchImpl?: ToolchainFetch;
-    hostNodeVersion?: string;
-    hostNpmVersion?: string;
-    signal?: AbortSignal;
-}
-export interface ProvisionNodeToolchainOptions {
-    commandExecutor?: ToolchainCommandExecutor;
-    fetchImpl?: ToolchainFetch;
-    productDir: string;
-    signal?: AbortSignal;
-    version: string;
-}
-export interface ProvisionedNodeToolchain {
-    binDir: string;
-    nodeExecutable: string;
-    npmVersion: string | null;
-    toolchainDir: string;
-}
-export declare function nodeToolchain(options?: NodeToolchainConfig): NodeToolchainConfig;
-export declare function normalizeToolchainRegistry(value: unknown): NormalizedToolchainRegistry;
-export declare function normalizeRuntimeToolchain(value: unknown, label: string, registry?: NormalizedToolchainRegistry): NormalizedRuntimeToolchain | null;
-export declare function resolveConfiguredToolchain(config: ToolchainRuntimeConfig | null | undefined, options?: ResolveConfiguredToolchainOptions): Promise<ResolvedNodeToolchain | null>;
-export declare function announceResolvedToolchain<Config extends ToolchainReportConfig>(config: Config, resolvedToolchain: ResolvedNodeToolchain | null, reporter?: ToolchainResolvedReporter<Config> | null): Promise<void>;
-export declare function applyToolchainEnv(baseEnv: Readonly<ToolchainEnvironment>, resolvedToolchain: ResolvedNodeToolchain | null, processEnv?: Readonly<ToolchainEnvironment>): ToolchainEnvironment;
-export declare function provisionNodeToolchain({ productDir, version, fetchImpl, commandExecutor, signal, }: ProvisionNodeToolchainOptions): Promise<ProvisionedNodeToolchain>;
-export declare function fetchToolchain(downloadUrl: string, options?: Readonly<ToolchainFetchOptions>): Promise<ToolchainDownloadResponse>;
-export declare function prepareToolchainCommandForManagedHost(command: string, args: readonly string[], options?: Readonly<{
-    env?: ToolchainEnvironment;
-    hostNodeExecutable?: string;
-    platform?: NodeJS.Platform;
-}>): PreparedManagedToolchainCommand;
-export declare function executeToolchainCommand(command: string, args: string[], options?: ToolchainCommandOptions): Promise<ToolchainCommandResult>;

package/dist/toolchains/managed-node-releases.d.ts

@@ -1,28 +0,0 @@
-import type { ArchiveFormat } from "./archive.js";
-import { type LinuxLibc, type PlatformTarget } from "../process/host/platform.js";
-export interface ManagedNodeArchiveLock {
-    readonly entryCount: number;
-    readonly fileCount: number;
-    readonly format: ArchiveFormat;
-    readonly rootDirectory: string;
-    readonly sha256: string;
-    readonly sizeBytes: number;
-    readonly unpackedSizeBytes: number;
-    readonly url: string;
-}
-export interface ManagedNodeInstalledTreeLock {
-    readonly entryCount: number;
-    readonly fileCount: number;
-    readonly sha256: string;
-    readonly unpackedSizeBytes: number;
-}
-export interface ManagedNodeRelease {
-    readonly archive: ManagedNodeArchiveLock;
-    readonly installed: ManagedNodeInstalledTreeLock;
-    readonly target: PlatformTarget;
-    readonly version: string;
-}
-export declare const MANAGED_NODE_RELEASES: readonly ManagedNodeRelease[];
-export declare const MANAGED_NODE_VERSIONS: readonly string[];
-export declare function managedNodeRelease(version: string, platform?: string, arch?: string, linuxLibc?: LinuxLibc | null): ManagedNodeRelease;
-export declare function assertManagedNodeReleaseHost(release: Readonly<ManagedNodeRelease>, linuxLibc?: LinuxLibc | null): void;

package/dist/toolchains/node-cache.d.ts

@@ -1,20 +0,0 @@
-import type { ManagedNodeRelease } from "./managed-node-releases.js";
-export declare const NODE_TOOLCHAIN_CONTENT_DIRECTORY = "content";
-export declare const NODE_TOOLCHAIN_MARKER_FILENAME = "toolchain.json";
-export interface NodeToolchainCachePaths {
-    readonly contentDirectory: string;
-    readonly installDirectory: string;
-    readonly lockPath: string;
-    readonly manifestPath: string;
-    readonly rootDirectory: string;
-}
-export declare function prepareNodeToolchainCache(productDir: string, release: Readonly<ManagedNodeRelease>): NodeToolchainCachePaths;
-export declare function nodeToolchainCacheKey(paths: Readonly<NodeToolchainCachePaths>): string;
-export declare function existingRealInstallDirectory(paths: Readonly<NodeToolchainCachePaths>): boolean;
-export declare function requireRealContentDirectory(paths: Readonly<NodeToolchainCachePaths>): void;
-export declare function readRealManifestFile(paths: Readonly<NodeToolchainCachePaths>): string | null;
-export declare function removeContainedInstallDirectory(paths: Readonly<NodeToolchainCachePaths>): void;
-export declare function createContainedTemporaryDirectory(rootDirectory: string, prefix: string): string;
-export declare function requireContainedExecutable(contentDirectory: string, relativePath: string, options: Readonly<{
-    allowSymbolicLink: boolean;
-}>): string;

package/dist/toolchains/node-integrity.d.ts

@@ -1,18 +0,0 @@
-import { type ArchiveEntry } from "./archive.js";
-import type { ManagedNodeInstalledTreeLock, ManagedNodeRelease } from "./managed-node-releases.js";
-export interface InstalledNodeTreeLimits {
-    readonly maxEntries: number;
-    readonly maxFiles: number;
-    readonly maxUnpackedSizeBytes: number;
-}
-export interface InstalledNodeTreeInspection {
-    readonly entryCount: number;
-    readonly fileCount: number;
-    readonly sha256: string;
-    readonly unpackedSizeBytes: number;
-}
-export declare function validateNodeArchiveEntries(entries: readonly ArchiveEntry[], release: Readonly<ManagedNodeRelease>): void;
-export declare function inspectInstalledNodeTree(root: string, limits: Readonly<InstalledNodeTreeLimits>, signal?: AbortSignal): Promise<InstalledNodeTreeInspection>;
-export declare class InstalledNodeTreeMismatchError extends Error {
-}
-export declare function verifyInstalledNodeTree(root: string, expected: Readonly<ManagedNodeInstalledTreeLock>, signal?: AbortSignal): Promise<void>;

package/dist/toolchains/node-provisioning.d.ts

@@ -1,29 +0,0 @@
-import { type ArchiveExtractor } from "./archive.js";
-import type { ProvisionedNodeToolchain, ToolchainCommandExecutor, ToolchainCommandOptions, ToolchainEnvironment, ToolchainFetch } from "./index.js";
-import type { ManagedNodeRelease } from "./managed-node-releases.js";
-export interface ProvisionNodeToolchainWithReleaseOptions {
-    readonly archiveTimeoutMs?: number;
-    readonly commandExecutor: ToolchainCommandExecutor;
-    readonly fetchImpl: ToolchainFetch;
-    readonly productDir: string;
-    readonly release: ManagedNodeRelease;
-    readonly signal?: AbortSignal;
-    readonly zipExtractor?: ArchiveExtractor;
-}
-export interface ExtractTrustedNodeArchiveOptions {
-    readonly archivePath: string;
-    readonly commandExecutor: ToolchainCommandExecutor;
-    readonly destination: string;
-    readonly release: ManagedNodeRelease;
-    readonly signal?: AbortSignal;
-    readonly timeoutMs?: number;
-    readonly zipExtractor?: ArchiveExtractor;
-}
-export declare function provisionNodeToolchainWithRelease({ archiveTimeoutMs, commandExecutor, fetchImpl, productDir, release, signal, zipExtractor, }: Readonly<ProvisionNodeToolchainWithReleaseOptions>): Promise<ProvisionedNodeToolchain>;
-export declare function extractTrustedNodeArchive({ archivePath, commandExecutor, destination, release, signal, timeoutMs, zipExtractor, }: Readonly<ExtractTrustedNodeArchiveOptions>): Promise<void>;
-export declare function renameNodeToolchainPublishDirectory(source: string, destination: string, signal?: AbortSignal): Promise<void>;
-export declare function nodeToolchainPublishRetryDelay(error: unknown, platform: NodeJS.Platform, attempt: number): number | null;
-export declare function nodeToolchainVersionInvocation(cwd: string, binDir: string, env: Readonly<ToolchainEnvironment>, prefixArgs?: readonly string[]): {
-    args: string[];
-    options: ToolchainCommandOptions;
-};

package/dist/toolchains/semver.d.ts

@@ -1,13 +0,0 @@
-export interface SemverVersion {
-    readonly major: number;
-    readonly minor: number;
-    readonly patch: number;
-}
-export type SemverInput = string | SemverVersion;
-export declare function normalizeSemver(input: unknown): string;
-export declare function isExactSemver(input: unknown): boolean;
-export declare function parseSemver(input: unknown): SemverVersion;
-export declare function compareSemver(left: SemverInput, right: SemverInput): number;
-export declare function formatSemver(version: SemverInput): string;
-export declare function satisfiesSemver(version: SemverInput, spec: unknown): boolean;
-export declare function deriveSemverMinimum(spec: unknown): string | null;

package/dist/toolchains/shared-operation.d.ts

@@ -1,11 +0,0 @@
-export interface SharedToolchainOperation<Result> {
-    readonly controller: AbortController;
-    promise: Promise<Result>;
-    settled: boolean;
-    waiters: number;
-}
-export declare function createSharedToolchainOperation<Result>(run: (signal: AbortSignal) => Promise<Result>): SharedToolchainOperation<Result>;
-export declare function waitForSharedToolchainOperation<Result>(operation: SharedToolchainOperation<Result>, signal?: AbortSignal): Promise<Result>;
-export declare function waitForPromise<Result>(promise: PromiseLike<Result>, signal?: AbortSignal): Promise<Result>;
-export declare function abortReason(signal: AbortSignal): Error;
-export declare function throwIfSignalAborted(signal?: AbortSignal): void;

package/dist/toolchains/timeouts.d.ts

@@ -1 +0,0 @@
-export declare const TOOLCHAIN_METADATA_TIMEOUT_MS: number;

package/dist/toolchains/vitest/index.d.ts

@@ -1,13 +0,0 @@
-type UnknownRecord = Record<string, unknown>;
-export interface VitestConfigOptions {
-    exclude?: readonly string[];
-}
-export type DefinedVitestConfig<TConfig extends UnknownRecord> = TConfig & {
-    test: UnknownRecord & {
-        exclude: string[];
-    };
-};
-export declare function defineConfig(): DefinedVitestConfig<Record<string, never>>;
-export declare function defineConfig<TConfig extends UnknownRecord>(config: TConfig, options?: VitestConfigOptions): DefinedVitestConfig<TConfig>;
-export declare function testkitExcludes(): string[];
-export {};

package/dist/tracker/gitea.d.ts

@@ -1,14 +0,0 @@
-import { type TrackerRequest } from "./http.js";
-import { type TrackerRepository } from "./requests.js";
-import type { Tracker, TrackerIssueDraft, TrackerLabel, TrackerTarget } from "./types.js";
-export declare function giteaHeaders(token: string): Record<string, string>;
-export declare function giteaRequests(repository: TrackerRepository): {
-    routes: import("./requests.js").TrackerRoutes;
-    createIssue: (draft: TrackerIssueDraft, labelIds: readonly number[]) => TrackerRequest;
-    createLabel: (label: TrackerLabel) => TrackerRequest;
-    listComments: (pullRequest: number, number: number) => TrackerRequest;
-    listLabels: (number: number) => TrackerRequest;
-    listOpenIssues: (label: string, number: number) => TrackerRequest;
-};
-export declare function readGiteaVersion(origin: string): Promise<string | null>;
-export declare function createGiteaTracker(target: TrackerTarget): Tracker;

package/dist/tracker/github.d.ts

@@ -1,14 +0,0 @@
-import { type TrackerRequest } from "./http.js";
-import { type TrackerRepository } from "./requests.js";
-import type { Tracker, TrackerIssueDraft, TrackerLabel, TrackerTarget } from "./types.js";
-export declare function githubHeaders(token: string): Record<string, string>;
-export declare function githubRequests(repository: TrackerRepository): {
-    routes: import("./requests.js").TrackerRoutes;
-    createIssue: (draft: TrackerIssueDraft) => TrackerRequest;
-    createLabel: (label: TrackerLabel) => TrackerRequest;
-    listComments: (pullRequest: number) => TrackerRequest;
-    listLabels: () => TrackerRequest;
-    listOpenIssues: (label: string) => TrackerRequest;
-    nextPage(link: string | null): TrackerRequest | null;
-};
-export declare function createGithubTracker(target: TrackerTarget): Tracker;

package/dist/tracker/http.d.ts

@@ -1,33 +0,0 @@
-import type { TrackerFailureKind } from "./types.js";
-export declare const TRACKER_PAGE_LIMIT = 1000;
-export declare class TrackerError extends Error {
-    readonly kind: TrackerFailureKind;
-    readonly status: number | null;
-    constructor(kind: TrackerFailureKind, message: string, status?: number | null);
-}
-export interface TrackerRequest {
-    readonly body?: unknown;
-    readonly method: "GET" | "PATCH" | "POST";
-    readonly url: string;
-}
-export interface TrackerResponse {
-    readonly body: unknown;
-    readonly headers: Headers;
-    readonly json: boolean;
-    readonly ok: boolean;
-    readonly source: string;
-    readonly status: number;
-}
-export interface TrackerHttpOptions {
-    readonly headers: Readonly<Record<string, string>>;
-    readonly label: string;
-    readonly secrets: readonly string[];
-}
-export interface TrackerHttp {
-    exchange(request: TrackerRequest): Promise<TrackerResponse>;
-    failure(response: TrackerResponse): TrackerError;
-    send(request: TrackerRequest): Promise<TrackerResponse>;
-}
-export declare function createTrackerHttp(options: TrackerHttpOptions): TrackerHttp;
-export declare function nextPageLink(link: string | null): string | null;
-export declare function scrubFailureDetail(text: string, secrets: readonly string[]): string;

package/dist/tracker/index.d.ts

@@ -1,4 +0,0 @@
-import type { Tracker, TrackerTarget } from "./types.js";
-export { TrackerError } from "./http.js";
-export type * from "./types.js";
-export declare function createTracker(target: TrackerTarget): Tracker;

package/dist/tracker/redaction.d.ts

@@ -1,4 +0,0 @@
-export declare function redactBugText(value: string): string;
-export declare function redactRunResultText(value: string): string;
-export declare function holdsRedaction(value: string): boolean;
-export declare function redactUntilUnchanged(value: string, redact: (text: string) => string): string;

package/dist/tracker/requests.d.ts

@@ -1,17 +0,0 @@
-import type { TrackerRequest } from "./http.js";
-import type { TrackerCommentRecord } from "./responses.js";
-import type { TrackerCommitStatus, TrackerPullRequestComment, TrackerTarget } from "./types.js";
-export declare const TRACKER_USER_AGENT = "testkit";
-export type TrackerRepository = Omit<TrackerTarget, "token">;
-export interface TrackerRoutes {
-    readonly issues: string;
-    readonly labels: string;
-    comment(id: number): string;
-    comments(pullRequest: number): string;
-    status(sha: string): string;
-}
-export declare function trackerRepository(target: TrackerTarget): TrackerRepository;
-export declare function trackerRoutes(repository: TrackerRepository): TrackerRoutes;
-export declare function getRequest(url: string, query: Readonly<Record<string, string>>): TrackerRequest;
-export declare function commitStatusRequest(routes: TrackerRoutes, status: TrackerCommitStatus): TrackerRequest;
-export declare function commentRequest(routes: TrackerRoutes, comment: TrackerPullRequestComment, existing: TrackerCommentRecord | undefined): TrackerRequest;

package/dist/tracker/responses.d.ts

@@ -1,24 +0,0 @@
-import type { TrackerIssue, TrackerTarget } from "./types.js";
-export interface TrackerLabelRecord {
-    readonly id: number;
-    readonly name: string;
-}
-export interface TrackerIssueRecord {
-    readonly issue: TrackerIssue;
-    readonly pullRequest: boolean;
-}
-export interface TrackerCommentRecord {
-    readonly body: string;
-    readonly id: number;
-    readonly url: string;
-}
-export declare function decodeTrackerLabel(value: unknown, source: string): TrackerLabelRecord;
-export declare function decodeTrackerLabels(value: unknown, source: string): TrackerLabelRecord[];
-export declare function decodeTrackerIssue(value: unknown, source: string): TrackerIssueRecord;
-export declare function requireIssueLabels(issue: TrackerIssue, labels: readonly string[], tracker: string, repository: Pick<TrackerTarget, "name" | "owner">): TrackerIssue;
-export declare function decodeTrackerIssues(value: unknown, source: string): TrackerIssueRecord[];
-export declare function decodeTrackerComment(value: unknown, source: string): TrackerCommentRecord;
-export declare function decodeTrackerComments(value: unknown, source: string): TrackerCommentRecord[];
-export declare function decodeTrackerCommitStatusContext(value: unknown, source: string): string;
-export declare function isDuplicateLabelRejection(value: unknown): boolean;
-export declare function decodeGiteaVersion(value: unknown): string | null;

package/dist/tracker/types.d.ts

@@ -1,51 +0,0 @@
-export type TrackerProvider = "gitea" | "github";
-export interface TrackerTarget {
-    readonly apiUrl: string;
-    readonly name: string;
-    readonly owner: string;
-    readonly provider: TrackerProvider;
-    readonly token: string;
-}
-export interface TrackerLabel {
-    readonly color: string;
-    readonly description: string;
-    readonly name: string;
-}
-export interface TrackerIssue {
-    readonly body: string;
-    readonly labels: readonly string[];
-    readonly number: number;
-    readonly title: string;
-    readonly url: string;
-}
-export interface TrackerIssueDraft {
-    readonly body: string;
-    readonly labels: readonly string[];
-    readonly title: string;
-}
-export type TrackerCommitState = "failure" | "success";
-export interface TrackerCommitStatus {
-    readonly context: string;
-    readonly description: string;
-    readonly sha: string;
-    readonly state: TrackerCommitState;
-    readonly targetUrl: string | null;
-}
-export interface TrackerPullRequestComment {
-    readonly body: string;
-    readonly marker: string;
-    readonly pullRequest: number;
-}
-export interface TrackerCommentReference {
-    readonly created: boolean;
-    readonly url: string;
-}
-export type TrackerFailureKind = "forbidden" | "not-found" | "rejected" | "unauthorized" | "unreachable";
-export interface Tracker {
-    readonly target: Omit<TrackerTarget, "token">;
-    createIssue(draft: TrackerIssueDraft): Promise<TrackerIssue>;
-    ensureLabels(labels: readonly TrackerLabel[]): Promise<void>;
-    listOpenIssues(label: string): Promise<readonly TrackerIssue[]>;
-    setCommitStatus(status: TrackerCommitStatus): Promise<void>;
-    upsertPullRequestComment(comment: TrackerPullRequestComment): Promise<TrackerCommentReference>;
-}