@pikku/core 0.12.148 → 0.12.151

package/dist/testing/trace-matrix/chain-harness.d.ts

@@ -0,0 +1,119 @@
+import { type TraceContext } from '../../trace.js';
+import { QueuedWorkflowHarness } from '../service-tests/queued-workflow-harness.js';
+import type { Hop, Inbound, Outcome, Start, Timing } from './dimensions.js';
+import { type EncodedJob } from './transports.js';
+import type { Adapter } from './dimensions.js';
+/** Runtime-specific paths are not here: Workers and Lambda stay mocked in their own packages. */
+export type ChainCombo = {
+    start: Start;
+    hop: Hop;
+    outcome: Outcome;
+    inbound?: Inbound;
+    timing?: Timing;
+    /** Chains to run at once, when two is not enough. */
+    instances?: number;
+    adapter?: Adapter;
+    workflow?: string;
+    step?: string;
+};
+export type LogEntry = {
+    level: 'info' | 'warn' | 'error' | 'debug';
+    /** The trace the logger was scoped to, if it was. */
+    scope?: string;
+    message: unknown;
+};
+/** What one started chain saw. A combo runs one, or two when timing overlaps them. */
+export type Instance = {
+    index: number;
+    sent?: string;
+    /** The caller itself was told of a failure, not only a job behind it. */
+    callerRefused?: boolean;
+    /** The caller's own span, for a start that is called rather than delivered. */
+    caller?: TraceContext;
+    /** Spans between an entry and a target, such as a scheduler's worker. */
+    relays: TraceContext[];
+    /** The wire trace at every run of the next hop, in order. */
+    targets: TraceContext[];
+    /** The `traceparent` the hop put on the wire. */
+    outgoing: string[];
+    errorId?: string;
+    /** Every span the entry ran as: one per delivery of a job. */
+    entries: TraceContext[];
+    /** `errorId` from the far side of a mesh hop. */
+    calleeErrorId?: string;
+    failure?: unknown;
+    entryFinishedAt?: number;
+    targetStartedAt: number[];
+    runId?: string;
+    job?: EncodedJob;
+};
+/** Starts whose function runs before a failure can be told from the wire alone. */
+export declare const inboundContinues: (start: Start, inbound: Inbound) => boolean;
+/**
+ * Runs a chain — a start, one hop, an outcome — through the real runners, with
+ * brokers and the network replaced by in-process stand-ins that keep their wire
+ * format. Nothing here decides a trace: every id comes from the code under test.
+ */
+export declare class TraceChain {
+    readonly combo: ChainCombo;
+    readonly logs: LogEntry[];
+    readonly h: QueuedWorkflowHarness;
+    readonly instances: Instance[];
+    private pending;
+    private scheduled;
+    /** Sleep wake-ups armed through the scheduler. */
+    readonly sleeps: Array<{
+        data: {
+            runId: string;
+            stepId: string;
+        };
+        traceparent?: string;
+    }>;
+    private settlers;
+    private readonly transport;
+    private readonly fetchBefore;
+    private jobIds;
+    readonly timing: Timing;
+    readonly inbound: Inbound;
+    private readonly outcome;
+    constructor(combo: ChainCombo);
+    private inboundFor;
+    private get usesFetch();
+    private logger;
+    private installServices;
+    private callMesh;
+    private installFetch;
+    /** Restores what the constructor replaced. Call in a `finally`. */
+    dispose(): void;
+    private wire;
+    /**
+     * Where the outcome lands: on the entry when the next hop runs nothing of
+     * ours, or when it is about the job the chain started as. Otherwise on the
+     * next function.
+     */
+    private get entryFails();
+    /** An HTTP route refusing a forged mesh token, before any function runs. */
+    get meshGuardsEntry(): boolean;
+    private get isSchemaOutcome();
+    private finishEntry;
+    private register;
+    private failTarget;
+    private wireStart;
+    private gatewayConfig;
+    private wireHop;
+    private hop;
+    private get jobOptions();
+    /** Runs the chain from its start, then every job and timer it left behind. */
+    run(): Promise<Instance[]>;
+    private settle;
+    private startInstance;
+    private drive;
+    private get startJobOptions();
+    private get singletons();
+    /** Delivers jobs and scheduled calls the way the adapter would. */
+    private deliver;
+    private deliverJob;
+    private deliveredOnce;
+    /** What a scheduler's worker does with a one-off `scheduleRPC`. */
+    private fire;
+}