@tangle-network/agent-eval 0.93.0 → 0.95.0

package/dist/campaign/distillation/cli.d.ts

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+/**
+ * `distill` — run a teacher→student GEPA distillation against a gold JSONL.
+ *
+ * The TEACHER is an expensive workflow whose verdicts are frozen as gold; the
+ * STUDENT is a cheap single-shot analyst whose system prompt GEPA optimizes
+ * toward reproducing those gold verdicts. This is the LIVE, token-spending
+ * entry — invoked by hand, never in CI.
+ *
+ * Usage:
+ *   distill \
+ *     --gold   <path/to/gold.jsonl> \
+ *     --baseline <path/to/baseline-prompt.txt> \
+ *     --model  <cheap-student-model> \
+ *     [--optimizer-model <reflection-model>] \
+ *     [--generations N] [--population K] [--reps R] \
+ *     [--test-every-nth 4] [--delta 0] \
+ *     [--categorical f1,f2] [--array a1,a2] \
+ *     [--run-dir <dir>]
+ *
+ * Auth: set LLM_API_KEY (+ optional LLM_BASE_URL) or TANGLE_API_KEY for the
+ * Tangle router. The same creds drive the student calls AND the GEPA
+ * reflection.
+ *
+ * Example (against the private skills-internal gold set, 53 records):
+ *   TANGLE_API_KEY=$(cat /tmp/.tk) pnpm tsx src/campaign/distillation/cli.ts \
+ *     --gold ~/code/skills-internal/audits/gold/skill-verdicts.gold.jsonl \
+ *     --baseline ./baseline-skill-analyst.txt \
+ *     --model gpt-4o-mini --optimizer-model gpt-4o \
+ *     --generations 3 --population 4 \
+ *     --categorical value_verdict,quality_score,generalization_rating,public_leak_risk,write_target_rating,subagent_recommended \
+ *     --array top_actions
+ */
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/campaign/distillation/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../../src/campaign/distillation/cli.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG"}

package/dist/campaign/distillation/distillation.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=distillation.test.d.ts.map

package/dist/campaign/distillation/distillation.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"distillation.test.d.ts","sourceRoot":"","sources":["../../../src/campaign/distillation/distillation.test.ts"],"names":[],"mappings":""}

package/dist/campaign/distillation/gold-scenarios.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Gold scenarios for teacher→student distillation. The TEACHER is an
+ * expensive workflow (e.g. the 70-agent skill audit) whose verdicts are
+ * frozen as gold labels; the STUDENT is a cheap single-shot analyst whose
+ * prompt GEPA optimizes toward reproducing those labels.
+ *
+ * A `GoldScenario` is a `Scenario` (the substrate's input contract) carrying
+ * an OPAQUE `input` (what the student sees) and an OPAQUE `label` (the gold
+ * verdict the student's output is scored against). Both are typed `unknown`
+ * here: this module is domain-agnostic — it distills ANY analyst against ANY
+ * gold JSONL. The agreement comparator (see `agreement-judge.ts`) is what
+ * knows the label's shape.
+ *
+ * Loading + splitting are DETERMINISTIC and LLM-free: the gold set is the
+ * fixed ground truth, never regenerated here.
+ */
+import type { Scenario } from '../types';
+/** A held gold record: opaque student-input + opaque gold-label, carried as a
+ *  substrate `Scenario` so it flows through `runCampaign` unchanged. */
+export interface GoldScenario<TInput = unknown, TLabel = unknown> extends Scenario {
+    kind: 'gold';
+    /** What the student analyst is shown (rendered into its user prompt). */
+    input: TInput;
+    /** The teacher's gold verdict — the target the student's output is scored
+     *  against by the agreement judge. NEVER shown to the student. */
+    label: TLabel;
+}
+/** Read a gold JSONL (one `{scenarioId|id, input, label, split?}` per line) into
+ *  `GoldScenario[]`. Deterministic, no LLM. Blank lines are skipped; a line
+ *  missing an id, `input`, or `label` throws (a silent skip would corrupt the
+ *  split silently — fail loud on a malformed gold set). */
+export declare function loadGoldScenarios<TInput = unknown, TLabel = unknown>(jsonlPath: string): GoldScenario<TInput, TLabel>[];
+/** Parse gold JSONL text directly (no fs). Exported so tests + in-memory
+ *  callers exercise the same parse path as {@link loadGoldScenarios}. */
+export declare function parseGoldJsonl<TInput = unknown, TLabel = unknown>(text: string, sourceLabel?: string): GoldScenario<TInput, TLabel>[];
+export interface SplitGoldOptions {
+    /** Every Nth scenario (0-based index) goes to the TEST/holdout split; the
+     *  rest train. Default 4 ⇒ a 25% holdout. Ignored for any scenario that
+     *  carries an explicit `split:` tag (that is honored verbatim). */
+    testEveryNth?: number;
+}
+export interface GoldSplit<TInput, TLabel> {
+    /** Training scenarios — the optimization pool the proposer searches over. */
+    train: GoldScenario<TInput, TLabel>[];
+    /** Held-out scenarios — kept OUT of training; scored only at the gate. */
+    test: GoldScenario<TInput, TLabel>[];
+}
+/** Deterministic train/test split. A scenario tagged `split:train|test` is
+ *  routed by that tag; the rest fall to a modulo split (`index % testEveryNth
+ *  === 0 ⇒ test`). Pure — same input always yields the same split, so a gold
+ *  set's holdout is stable across runs (a shuffled split would let a lucky
+ *  seed flatter the gate). */
+export declare function splitGold<TInput, TLabel>(scenarios: GoldScenario<TInput, TLabel>[], options?: SplitGoldOptions): GoldSplit<TInput, TLabel>;
+//# sourceMappingURL=gold-scenarios.d.ts.map

package/dist/campaign/distillation/gold-scenarios.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gold-scenarios.d.ts","sourceRoot":"","sources":["../../../src/campaign/distillation/gold-scenarios.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAExC;wEACwE;AACxE,MAAM,WAAW,YAAY,CAAC,MAAM,GAAG,OAAO,EAAE,MAAM,GAAG,OAAO,CAAE,SAAQ,QAAQ;IAChF,IAAI,EAAE,MAAM,CAAA;IACZ,yEAAyE;IACzE,KAAK,EAAE,MAAM,CAAA;IACb;sEACkE;IAClE,KAAK,EAAE,MAAM,CAAA;CACd;AAYD;;;2DAG2D;AAC3D,wBAAgB,iBAAiB,CAAC,MAAM,GAAG,OAAO,EAAE,MAAM,GAAG,OAAO,EAClE,SAAS,EAAE,MAAM,GAChB,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAGhC;AAED;yEACyE;AACzE,wBAAgB,cAAc,CAAC,MAAM,GAAG,OAAO,EAAE,MAAM,GAAG,OAAO,EAC/D,IAAI,EAAE,MAAM,EACZ,WAAW,SAAa,GACvB,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAmDhC;AAED,MAAM,WAAW,gBAAgB;IAC/B;;uEAEmE;IACnE,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,SAAS,CAAC,MAAM,EAAE,MAAM;IACvC,6EAA6E;IAC7E,KAAK,EAAE,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAA;IACrC,0EAA0E;IAC1E,IAAI,EAAE,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAA;CACrC;AAED;;;;8BAI8B;AAC9B,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EACtC,SAAS,EAAE,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EACzC,OAAO,GAAE,gBAAqB,GAC7B,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAuB3B"}

package/dist/campaign/distillation/run-distillation.d.ts

@@ -0,0 +1,119 @@
+/**
+ * `runDistillation` — the teacher→student distillation loop. COMPOSES existing
+ * substrate primitives; reimplements none of them:
+ *
+ *   - DRIVER       = `gepaProposer` (reflective prompt optimizer)
+ *   - LOOP         = `runImprovementLoop` (outer: optimize → holdout re-score → gate)
+ *   - MEASUREMENT  = `runCampaign` (inside the loop) scoring the student
+ *   - JUDGE        = `buildAgreementJudge` — student label vs gold teacher label
+ *   - GATE         = caller-supplied (`heldOutGate` / `defaultProductionGate`)
+ *   - STUDENT      = a cheap single-shot analyst whose system prompt is the
+ *                    `MutableSurface` GEPA mutates; it calls the LLM through
+ *                    `createChatClient` and emits a JSON label.
+ *
+ * The surface IS the student's system prompt. Each generation GEPA rewrites it;
+ * `dispatchWithSurface` renders {surface + scenario.input} into a chat request,
+ * calls the (cheap) model, parses the produced JSON label, and returns it as
+ * the artifact. The agreement judge scores that label against the gold label.
+ *
+ * `autoOnPromote: 'none'` is FORCED — the loop never opens a PR; the caller
+ * (the `distill` CLI) decides what to do with the winning prompt.
+ */
+import { type ChatRequest, type CreateChatClientOpts } from '../../analyst/chat-client';
+import type { LlmClientOptions } from '../../llm-client';
+import { type RunImprovementLoopResult } from '../presets/run-improvement-loop';
+import { type GepaProposerConstraints } from '../proposers/gepa';
+import type { CampaignResult, Gate, JudgeConfig } from '../types';
+import type { GoldScenario } from './gold-scenarios';
+/** Render the student's prompt from {current surface, scenario input}. The
+ *  surface is the system prompt; the scenario input is the user turn. Override
+ *  to inject few-shot framing or a JSON-schema reminder. */
+export type RenderStudentPrompt<TInput> = (args: {
+    surface: string;
+    input: TInput;
+    scenarioId: string;
+}) => ChatRequest['messages'];
+/** Parse the model's raw text into a typed produced label. Throws on
+ *  unparseable output — a thrown dispatch is recorded as a failed cell (never
+ *  silently scored 0), which is the honest signal that the prompt isn't
+ *  emitting valid JSON yet. */
+export type ParseStudentLabel<TProduced> = (rawContent: string, scenarioId: string) => TProduced;
+export interface RunDistillationOptions<TProduced, TInput, TLabel> {
+    /** The student analyst's INITIAL system prompt — the baseline surface GEPA
+     *  searches from. */
+    baselinePrompt: string;
+    /** Training scenarios (the optimization pool). */
+    train: GoldScenario<TInput, TLabel>[];
+    /** Held-out scenarios — kept OUT of training; scored only at the gate. */
+    holdout: GoldScenario<TInput, TLabel>[];
+    /** Transport for BOTH the student (cheap model) and the GEPA reflection
+     *  (the optimizer model). The student calls it via `createChatClient`. */
+    llm: CreateChatClientOpts;
+    /** Router transport the GEPA proposer reflects through. `gepaProposer` uses the
+     *  package `LlmClient` directly (`LlmClientOptions`), not the ChatClient —
+     *  pass the router creds here. A test may inject `fetch` to stub the
+     *  reflection HTTP and exercise the wiring without real tokens. */
+    reflectionLlm: LlmClientOptions;
+    /** Cheap model the student runs (e.g. a small/fast model). */
+    studentModel: string;
+    /** Model GEPA uses to propose prompt rewrites (typically a stronger model). */
+    optimizerModel: string;
+    /** Agreement judge — produced student label vs gold teacher label. */
+    judge: JudgeConfig<TProduced, GoldScenario<TInput, TLabel>>;
+    /** Promotion gate. Default: `heldOutGate` over the holdout. Pass
+     *  `defaultProductionGate({ holdoutScenarios: holdout, ... })` for the full
+     *  red-team / reward-hacking / canary stack. */
+    gate?: Gate<TProduced, GoldScenario<TInput, TLabel>>;
+    /** GEPA population size (candidates per generation). Default 4. */
+    populationSize?: number;
+    /** GEPA generations. Default 3. */
+    maxGenerations?: number;
+    /** Campaign reps per scenario. Default 1 — raise for CI bands on a flaky
+     *  student. */
+    reps?: number;
+    /** Where campaign artifacts + traces land. Default a temp dir under cwd. */
+    runDir?: string;
+    /** Levers offered to the GEPA reflection prompt. */
+    mutationPrimitives?: string[];
+    /** GEPA structured-doc constraints (preserve sections, edit budget). */
+    constraints?: GepaProposerConstraints;
+    /** Gate's minimum holdout-agreement delta to ship. Default 0.0 — a
+     *  distillation run reports the lift; the caller decides the bar. Only used
+     *  when `gate` is omitted (the default `heldOutGate`). */
+    deltaThreshold?: number;
+    /** Render the student prompt. Default: surface as system, JSON-stringified
+     *  input as the user turn with a JSON-only instruction. */
+    renderStudentPrompt?: RenderStudentPrompt<TInput>;
+    /** Parse the model's text into a produced label. Default: strict JSON parse
+     *  with fenced-block stripping. */
+    parseStudentLabel?: ParseStudentLabel<TProduced>;
+    /** Per-student-call sampling temperature. Default 0 (deterministic student;
+     *  the optimization signal must come from the PROMPT, not sampling noise). */
+    studentTemperature?: number;
+    /** Per-student-call max tokens. Default 1024. */
+    studentMaxTokens?: number;
+}
+export interface RunDistillationResult<TProduced, TInput, TLabel> extends RunImprovementLoopResult<TProduced, GoldScenario<TInput, TLabel>> {
+    /** The winning student prompt (a string surface). */
+    winnerPrompt: string;
+    /** Mean agreement on the HOLDOUT — baseline vs winner. The headline number:
+     *  did distillation move the student closer to the teacher on UNSEEN gold? */
+    holdoutAgreement: {
+        baseline: number;
+        winner: number;
+        delta: number;
+    };
+}
+export declare function runDistillation<TProduced, TInput, TLabel>(opts: RunDistillationOptions<TProduced, TInput, TLabel>): Promise<RunDistillationResult<TProduced, TInput, TLabel>>;
+/** Default student prompt render: surface as system, JSON input as the user
+ *  turn, with a JSON-only output instruction. */
+export declare function defaultRenderStudentPrompt<TInput>(args: {
+    surface: string;
+    input: TInput;
+    scenarioId: string;
+}): ChatRequest['messages'];
+/** Default label parse: strip a ```json fence if present, then `JSON.parse`.
+ *  Throws on failure so the cell is recorded as failed, not silently zeroed. */
+export declare function defaultParseStudentLabel<TProduced>(rawContent: string, scenarioId: string): TProduced;
+export type { CampaignResult };
+//# sourceMappingURL=run-distillation.d.ts.map

package/dist/campaign/distillation/run-distillation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-distillation.d.ts","sourceRoot":"","sources":["../../../src/campaign/distillation/run-distillation.ts"],"names":[],"mappings":"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"}

package/dist/campaign/gates/compose.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Compose multiple `Gate` implementations — every gate must pass for the
+ * composite to ship. Closes the alignment reviewer's "default-only
+ * heldOutGate + costGate would happily promote a reward-hacked prompt"
+ * concern by making safety gates first-class composable defaults.
+ */
+import type { Gate, Scenario } from '../types';
+/** Compose gates — all must `ship` for the composite to `ship`. First
+ *  non-ship verdict short-circuits the composite verdict, but ALL gates run
+ *  (so the result records every gate's reason — useful for diagnostics). */
+export declare function composeGate<TArtifact = unknown, TScenario extends Scenario = Scenario>(...gates: Array<Gate<TArtifact, TScenario>>): Gate<TArtifact, TScenario>;
+//# sourceMappingURL=compose.d.ts.map

package/dist/campaign/gates/compose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../../../src/campaign/gates/compose.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAyC,QAAQ,EAAE,MAAM,UAAU,CAAA;AAErF;;4EAE4E;AAC5E,wBAAgB,WAAW,CAAC,SAAS,GAAG,OAAO,EAAE,SAAS,SAAS,QAAQ,GAAG,QAAQ,EACpF,GAAG,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,GAC1C,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,CAgD5B"}

package/dist/campaign/gates/default-production-gate.d.ts

@@ -0,0 +1,58 @@
+/**
+ * `defaultProductionGate` — composes the substrate's existing safety
+ * primitives (red-team / reward-hacking / canary / heldout) into a single
+ * Gate.decide shape. Closes the alignment + Anthropic-SI reviewers' "safety
+ * primitives are off the critical path" blocker.
+ *
+ * The composition is opinionated — when consumers wire `runImprovementLoop`,
+ * THIS gate is the default. Consumers can still pass a custom gate to
+ * override; the recommended pattern is to compose THIS gate with whatever
+ * extra domain-specific gates they need (`composeGate(defaultProductionGate(...), customGate)`).
+ */
+import type { RedTeamCase } from '../../red-team';
+import type { RunRecord } from '../../run-record';
+import type { Gate, Scenario } from '../types';
+export interface DefaultProductionGateOptions {
+    /** Required: scenarios held out from training; substrate compares
+     *  candidate-on-holdout vs baseline-on-holdout. */
+    holdoutScenarios: Scenario[];
+    /** Minimum held-out lift the **paired-bootstrap CI lower bound** must clear
+     *  to ship — NOT a point estimate. Default 0 ⇒ "confidently positive at the
+     *  confidence level". Interpreted in the judge's native composite scale (set
+     *  e.g. 2 for a 0-100 rubric to require a ≥2-point significant gain). */
+    deltaThreshold?: number;
+    /** Confidence level for the held-out + dimension bootstraps. Default 0.95. */
+    confidence?: number;
+    /** Bootstrap resamples. Default 2000. */
+    bootstrapResamples?: number;
+    /** Fixed bootstrap seed for a deterministic verdict. Default 1337. */
+    bootstrapSeed?: number;
+    /** Minimum paired holdout observations (scenarios × reps) before a
+     *  significance claim is allowed; below it the gate HOLDS with `few_runs`
+     *  rather than reading a degenerate CI. Default 3. */
+    minProductiveRuns?: number;
+    /** Critical judge dimensions that must NOT significantly regress even when
+     *  the net composite rises (anti-Goodhart). The gate HOLDS if any listed
+     *  dimension's paired-delta CI lower bound < −`regressionTolerance`. E.g.
+     *  `['hallucination_free']` for a legal agent. */
+    criticalDimensions?: string[];
+    /** Tolerance for the per-dimension regression guard, in the dimension's
+     *  native scale. When omitted it auto-scales off observed magnitudes:
+     *  0.05 on [0,1], 5 on 0-100. */
+    regressionTolerance?: number;
+    /** Total $ budget for ALL cells in this campaign — including baseline + candidate.
+     *  Composite verdict refuses to ship when spend exceeded budget. */
+    budgetUsd?: number;
+    /** Red-team cases to probe candidate outputs against. When omitted the
+     *  substrate uses `DEFAULT_RED_TEAM_CORPUS`. Provide a domain-specific
+     *  battery for tighter coverage. */
+    redTeamBattery?: RedTeamCase[];
+    /** Run records (oldest-first) needed for the reward-hacking detector.
+     *  Substrate populates from prior production-loop generations. */
+    recentRuns?: RunRecord[];
+    /** When true, the gate refuses to ship if the reward-hacking detector
+     *  fires at the `gaming` severity. Default true. */
+    blockOnRewardHackingGaming?: boolean;
+}
+export declare function defaultProductionGate<TArtifact, TScenario extends Scenario>(options: DefaultProductionGateOptions): Gate<TArtifact, TScenario>;
+//# sourceMappingURL=default-production-gate.d.ts.map

package/dist/campaign/gates/default-production-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-production-gate.d.ts","sourceRoot":"","sources":["../../../src/campaign/gates/default-production-gate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAIjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AACjD,OAAO,KAAK,EAAE,IAAI,EAA2B,QAAQ,EAAE,MAAM,UAAU,CAAA;AAGvE,MAAM,WAAW,4BAA4B;IAC3C;uDACmD;IACnD,gBAAgB,EAAE,QAAQ,EAAE,CAAA;IAC5B;;;6EAGyE;IACzE,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,8EAA8E;IAC9E,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,yCAAyC;IACzC,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,sEAAsE;IACtE,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;0DAEsD;IACtD,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B;;;sDAGkD;IAClD,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC7B;;qCAEiC;IACjC,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B;wEACoE;IACpE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;wCAEoC;IACpC,cAAc,CAAC,EAAE,WAAW,EAAE,CAAA;IAC9B;sEACkE;IAClE,UAAU,CAAC,EAAE,SAAS,EAAE,CAAA;IACxB;wDACoD;IACpD,0BAA0B,CAAC,EAAE,OAAO,CAAA;CACrC;AAED,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,SAAS,SAAS,QAAQ,EACzE,OAAO,EAAE,4BAA4B,GACpC,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,CAuL5B"}

package/dist/campaign/gates/heldout-gate.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Thin Gate adapter — exposes delta-threshold-on-holdout as a composable
+ * `Gate`. Use when you want held-out as one of N composed gates instead of
+ * the full `defaultProductionGate` stack.
+ */
+import type { Gate, Scenario } from '../types';
+export interface HeldOutGateOptions<TScenario extends Scenario = Scenario> {
+    scenarios: TScenario[];
+    deltaThreshold?: number;
+}
+export declare function heldOutGate<TArtifact, TScenario extends Scenario>(options: HeldOutGateOptions<TScenario>): Gate<TArtifact, TScenario>;
+//# sourceMappingURL=heldout-gate.d.ts.map

package/dist/campaign/gates/heldout-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heldout-gate.d.ts","sourceRoot":"","sources":["../../../src/campaign/gates/heldout-gate.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,IAAI,EAA2B,QAAQ,EAAE,MAAM,UAAU,CAAA;AAEvE,MAAM,WAAW,kBAAkB,CAAC,SAAS,SAAS,QAAQ,GAAG,QAAQ;IACvE,SAAS,EAAE,SAAS,EAAE,CAAA;IACtB,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB;AAED,wBAAgB,WAAW,CAAC,SAAS,EAAE,SAAS,SAAS,QAAQ,EAC/D,OAAO,EAAE,kBAAkB,CAAC,SAAS,CAAC,GACrC,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,CAwB5B"}

package/dist/campaign/gates/promotion-policy.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Promotion policy over the evidence VECTOR — the substrate's answer to "never
+ * collapse the multi-objective promotion decision into one scalar." A
+ * `defaultProductionGate` is one opinionated composition; this module factors
+ * the decision into two reusable pieces so MANY policies can compete over the
+ * SAME evidence (the quant-desk pattern: one evidence bus, plural strategies):
+ *
+ *   buildEvidenceVector(ctx, objectives, opts) -> EvidenceVector   // the bus
+ *   PromotionPolicy = (ev: EvidenceVector) => GateResult           // a strategy
+ *   paretoPolicy(ev)                                               // the default strategy
+ *   paretoSignificanceGate(options): Gate                          // bus + policy as a Gate
+ *
+ * The Pareto policy is SYMMETRIC multi-objective: every objective is BOTH a
+ * potential gain source AND a safety floor (unlike `defaultProductionGate`,
+ * where only `composite` can win and `criticalDimensions` are pure floors). A
+ * candidate ships iff it weakly DOMINATES the baseline at the confidence level —
+ * no objective credibly worse (CI floor breach) AND at least one objective
+ * credibly better (CI gain). Insufficient evidence on ANY axis -> need_more_work
+ * (NOT folded into hold: "gather more reps" and "reject" are different actions).
+ *
+ * Cost/latency are NOT CI axes here — `GateContext` carries only an aggregate
+ * per-side cost, no per-cell observation vector to bootstrap. Treat them as hard
+ * constraints (compose with a budget gate via `composeGate`), not faked CIs.
+ */
+import type { Direction } from '../../pareto';
+import { type PairedBootstrapResult } from '../../statistics';
+import type { Gate, GateContext, GateResult, Scenario } from '../types';
+/** Where an objective's per-cell scalar comes from. `composite` reads the
+ *  judge's composite; `dimension` reads a named per-dimension score. */
+export type ObjectiveSource = {
+    kind: 'composite';
+} | {
+    kind: 'dimension';
+    dimension: string;
+};
+export interface PromotionObjective {
+    /** Stable label used in reports + `contributingGates`. */
+    name: string;
+    source: ObjectiveSource;
+    /** 'maximize' (quality dims) or 'minimize' (error/risk/length dims). Orients
+     *  the paired delta so a positive bootstrap always means "candidate better". */
+    direction: Direction;
+    /** The good-direction paired-delta CI lower bound must EXCEED this to count
+     *  as a significant gain on this axis. Interpreted in the judge's native
+     *  scale. Default 0 (⇒ "confidently better"). */
+    gainThreshold?: number;
+    /** A floor breach (regression) is declared when the good-direction CI lower
+     *  bound is below −floorTolerance. When omitted it auto-scales off observed
+     *  magnitudes (0.05 on [0,1], 5 on 0-100), matching `dimensionRegressions`. */
+    floorTolerance?: number;
+}
+/** Per-axis verdict from the good-direction paired bootstrap. */
+export type AxisVerdict = 'improved' | 'regressed' | 'flat' | 'few_runs';
+export interface AxisEvidence {
+    name: string;
+    source: ObjectiveSource;
+    direction: Direction;
+    /** Paired bootstrap on the GOOD-DIRECTION delta (oriented by `direction`):
+     *  a positive value means the candidate is better on this axis. */
+    bootstrap: PairedBootstrapResult;
+    /** Paired observations contributing to this axis. */
+    n: number;
+    gainThreshold: number;
+    floorTolerance: number;
+    verdict: AxisVerdict;
+}
+export interface EvidenceVector {
+    /** One entry per objective — NOTHING averaged across axes. */
+    axes: AxisEvidence[];
+    /** Smallest paired n across axes that produced observations — the binding
+     *  evidence-sufficiency constraint. 0 when no axis produced observations. */
+    minN: number;
+    /** Aggregate per-side cost from the gate context (a constraint input, not a
+     *  CI axis — see the module header). */
+    cost: {
+        candidate: number;
+        baseline: number;
+    };
+}
+/** A promotion strategy: a pure function from the evidence vector to a verdict.
+ *  Many policies can run over the same `EvidenceVector` and disagree — that's
+ *  the point (competing strategies, shared evidence). */
+export type PromotionPolicy = (ev: EvidenceVector) => GateResult;
+export interface BuildEvidenceVectorOptions {
+    /** Minimum paired observations before an axis can claim significance; below
+     *  it the axis is `few_runs`. Default 3. */
+    minProductiveRuns?: number;
+    /** Confidence level for every axis bootstrap. Default 0.95. */
+    confidence?: number;
+    /** Bootstrap resamples. Default 2000. */
+    resamples?: number;
+    /** Fixed bootstrap seed for a deterministic, reproducible verdict. Default 1337. */
+    seed?: number;
+}
+/**
+ * The Evidence Bus. For each objective, pair candidate vs baseline by full
+ * cellId and bootstrap a CI on the good-direction paired delta. Reuses the
+ * exact `pairHoldout` + `pairedBootstrap` machinery the held-out gate uses, so
+ * a single source of truth governs pairing granularity + scale handling.
+ */
+export declare function buildEvidenceVector<TArtifact, TScenario extends Scenario>(ctx: GateContext<TArtifact, TScenario>, objectives: PromotionObjective[], opts?: BuildEvidenceVectorOptions): EvidenceVector;
+/**
+ * The default strategy: symmetric multi-objective Pareto significance. Ship iff
+ * the candidate weakly dominates the baseline at the confidence level — no axis
+ * credibly worse AND ≥1 axis credibly better. Floor breach on any axis → hold
+ * (anti-Goodhart, dominates everything). Insufficient evidence on any axis →
+ * need_more_work. Statistically equivalent → hold (never ship noise).
+ */
+export declare const paretoPolicy: PromotionPolicy;
+export interface ParetoSignificanceGateOptions extends BuildEvidenceVectorOptions {
+    /** The objective vector. Every axis is both a gain source and a safety floor. */
+    objectives: PromotionObjective[];
+    /** Strategy applied to the evidence vector. Default `paretoPolicy`. Override
+     *  to run a stricter/looser strategy over the SAME bus (competing policies). */
+    policy?: PromotionPolicy;
+    /** Override the gate name in reports. */
+    name?: string;
+}
+/**
+ * Wrap the bus + a policy as a `Gate`. Plugs into the existing
+ * `runImprovementLoop({ gate })` slot and composes via `composeGate`; default
+ * loop behavior is unchanged because consumers opt in by passing this gate.
+ */
+export declare function paretoSignificanceGate<TArtifact = unknown, TScenario extends Scenario = Scenario>(options: ParetoSignificanceGateOptions): Gate<TArtifact, TScenario>;
+//# sourceMappingURL=promotion-policy.d.ts.map

package/dist/campaign/gates/promotion-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promotion-policy.d.ts","sourceRoot":"","sources":["../../../src/campaign/gates/promotion-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,EAAE,KAAK,qBAAqB,EAAmB,MAAM,kBAAkB,CAAA;AAC9E,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAgB,UAAU,EAAc,QAAQ,EAAE,MAAM,UAAU,CAAA;AAGjG;wEACwE;AACxE,MAAM,MAAM,eAAe,GAAG;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAA;AAE9F,MAAM,WAAW,kBAAkB;IACjC,0DAA0D;IAC1D,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,eAAe,CAAA;IACvB;oFACgF;IAChF,SAAS,EAAE,SAAS,CAAA;IACpB;;qDAEiD;IACjD,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;mFAE+E;IAC/E,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB;AAED,iEAAiE;AACjE,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,WAAW,GAAG,MAAM,GAAG,UAAU,CAAA;AAExE,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,eAAe,CAAA;IACvB,SAAS,EAAE,SAAS,CAAA;IACpB;uEACmE;IACnE,SAAS,EAAE,qBAAqB,CAAA;IAChC,qDAAqD;IACrD,CAAC,EAAE,MAAM,CAAA;IACT,aAAa,EAAE,MAAM,CAAA;IACrB,cAAc,EAAE,MAAM,CAAA;IACtB,OAAO,EAAE,WAAW,CAAA;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,8DAA8D;IAC9D,IAAI,EAAE,YAAY,EAAE,CAAA;IACpB;iFAC6E;IAC7E,IAAI,EAAE,MAAM,CAAA;IACZ;4CACwC;IACxC,IAAI,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAA;CAC9C;AAED;;yDAEyD;AACzD,MAAM,MAAM,eAAe,GAAG,CAAC,EAAE,EAAE,cAAc,KAAK,UAAU,CAAA;AAEhE,MAAM,WAAW,0BAA0B;IACzC;gDAC4C;IAC5C,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,+DAA+D;IAC/D,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,yCAAyC;IACzC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,oFAAoF;IACpF,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,SAAS,SAAS,QAAQ,EACvE,GAAG,EAAE,WAAW,CAAC,SAAS,EAAE,SAAS,CAAC,EACtC,UAAU,EAAE,kBAAkB,EAAE,EAChC,IAAI,GAAE,0BAA+B,GACpC,cAAc,CA+DhB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,EAAE,eAoE1B,CAAA;AAED,MAAM,WAAW,6BAA8B,SAAQ,0BAA0B;IAC/E,iFAAiF;IACjF,UAAU,EAAE,kBAAkB,EAAE,CAAA;IAChC;oFACgF;IAChF,MAAM,CAAC,EAAE,eAAe,CAAA;IACxB,yCAAyC;IACzC,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,GAAG,OAAO,EAAE,SAAS,SAAS,QAAQ,GAAG,QAAQ,EAC/F,OAAO,EAAE,6BAA6B,GACrC,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,CAY5B"}

package/dist/campaign/gates/promotion-policy.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=promotion-policy.test.d.ts.map

package/dist/campaign/gates/promotion-policy.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promotion-policy.test.d.ts","sourceRoot":"","sources":["../../../src/campaign/gates/promotion-policy.test.ts"],"names":[],"mappings":""}

package/dist/campaign/gates/sequential.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Anytime-valid sequential promotion gate — an e-process (betting
+ * test-martingale, see `eProcess` in `statistics.ts`) over paired
+ * per-scenario deltas, so a campaign stops the MOMENT evidence decides
+ * instead of burning a fixed-n budget. Decisions remain valid at any
+ * data-dependent stopping time (Ville's inequality), which is exactly what
+ * fixed-n machinery cannot offer: peeking at a bootstrap CI after every
+ * observation and stopping on the first significant peek inflates type-I
+ * error far beyond alpha.
+ *
+ * REPLACES, never layers on, a fixed-n gate. Running `heldoutSignificance`
+ * or `paretoSignificanceGate` repeatedly on a growing sample and stopping
+ * early is optional stopping no matter how it is dressed up; this gate is
+ * the valid way to stop early. Use one or the other per evidence stream.
+ *
+ * Pre-registration binding: anytime validity holds only for the
+ * PRE-REGISTERED statistic. When a `SignedManifest` is bound, the gate takes
+ * alpha from `manifest.alpha`, the observation budget from
+ * `manifest.preRegisteredN`, orients deltas by `manifest.direction`, and
+ * shifts the null boundary by `manifest.minEffect` — re-deciding the same
+ * stream under different parameters after seeing data would reopen optional
+ * stopping under a fancier name. The manifest's content hash is verified at
+ * construction (sync, same `sha256-content` scheme as `signManifest`).
+ *
+ * Non-iid caveat (stated honestly): the supermartingale guarantee needs each
+ * delta's conditional mean under H0 to stay ≤ the null boundary given the
+ * past — exchangeable scenario deltas suffice. Scenario streams ordered by
+ * difficulty or by scenario family violate this; `decide(ctx)` therefore
+ * shuffles the paired deltas with a SEEDED permutation by default (the
+ * permutation is data-independent, so bet predictability is preserved).
+ * Stratified betting (per-stratum λ) is future work, not implemented here.
+ */
+import { type SignedManifest } from '../../pre-registration';
+import { type EProcessState } from '../../statistics';
+import type { Gate, GenerationRecord, Scenario } from '../types';
+export type SequentialDecision = 'promote' | 'continue' | 'undecided-at-maxN';
+export interface SequentialObservation {
+    decision: SequentialDecision;
+    /** Current e-value (the betting wealth) against H0. */
+    eValue: number;
+    /** Paired deltas consumed so far. */
+    n: number;
+    /** Names the decision basis. For 'undecided-at-maxN' it states explicitly
+     *  that exhausting the budget is NOT evidence of no effect. */
+    reason: string;
+}
+export interface SequentialPairedGateOptions {
+    /** Type-I budget. With `preRegistration` bound this MUST match
+     *  `manifest.alpha` (conflict throws). Default 0.05. */
+    alpha?: number;
+    /** Minimum paired deltas before a promote may fire. The stopping rule is
+     *  "first n ≥ minN with e-value ≥ 1/alpha" — still a valid stopping time.
+     *  Default 5. */
+    minN?: number;
+    /** Pre-registered observation budget. Required unless `preRegistration`
+     *  supplies it via `preRegisteredN` (conflict throws). */
+    maxN?: number;
+    /** Bet truncation forwarded to `eProcess`. Default 0.5. */
+    maxBet?: number;
+    /** Bound on |delta| in the judge's native scale; deltas are mapped to
+     *  x = (d/scale + 1)/2 ∈ [0,1]. A delta outside ±scale throws (use
+     *  `detectScale` to pick 1 vs 100 BEFORE streaming). Default 1. */
+    scale?: number;
+    /** Seed for the data-independent shuffle of paired deltas in `decide(ctx)`
+     *  (exchangeability guard). Default 1337. */
+    shuffleSeed?: number;
+    /** Bind the pre-registered hypothesis. Verified (content hash) at
+     *  construction; alpha/maxN/direction/minEffect come FROM the manifest. */
+    preRegistration?: SignedManifest;
+    /** Override the gate name in reports. */
+    name?: string;
+}
+export interface SequentialPairedGate<TArtifact = unknown, TScenario extends Scenario = Scenario> extends Gate<TArtifact, TScenario> {
+    /** Streaming entry point: feed one paired per-scenario delta
+     *  (candidate − baseline, native scale). Each gate instance carries ONE
+     *  observe-stream; `decide(ctx)` runs on its own fresh stream and never
+     *  consumes or advances this one. 'promote' is sticky; observing past the
+     *  pre-registered maxN throws (extending a finished stream after seeing
+     *  the result reopens optional stopping — start a NEW pre-registered
+     *  test). */
+    observe(delta: number): SequentialObservation;
+    /** Read-only snapshot of the observe-stream. */
+    state(): EProcessState & {
+        decision: SequentialDecision;
+    };
+}
+/**
+ * Anytime-valid sequential paired gate. Conforms to the existing `Gate`
+ * contract (`decide(ctx)` consumes candidate vs baseline judge scores via
+ * `pairHoldout` — same pairing granularity as the fixed-n gates: full cellId,
+ * never scenarioId) and adds a streaming `observe(delta)` entry for campaigns
+ * that score cells incrementally and want to stop mid-stream.
+ *
+ * Decision mapping onto the substrate's five-valued `GateDecision`:
+ *   - 'promote'            → 'ship'
+ *   - 'continue'           → 'need_more_work' (stream ended before maxN with
+ *                            the e-value undecided — more reps could decide)
+ *   - 'undecided-at-maxN'  → 'hold', with the reason stating it is NOT
+ *                            evidence of no effect (never a silent default)
+ */
+export declare function sequentialPairedGate<TArtifact = unknown, TScenario extends Scenario = Scenario>(options: SequentialPairedGateOptions): SequentialPairedGate<TArtifact, TScenario>;
+export interface SequentialDecideOptions {
+    /** Type-I budget for the early-stop evidence. Default 0.05. */
+    alpha?: number;
+    /** Minimum paired deltas before a stop may fire. Default 5. */
+    minN?: number;
+    /** Bet truncation forwarded to `eProcess`. Default 0.5. */
+    maxBet?: number;
+    /** Bound on |per-scenario composite delta|. Default 1. */
+    scale?: number;
+}
+export interface SequentialDecideFn {
+    (args: {
+        history: GenerationRecord[];
+    }): {
+        stop: boolean;
+        reason?: string;
+    };
+    /** Read-only snapshot of the accumulated e-process (observability + tests). */
+    state(): EProcessState;
+}
+/**
+ * `SurfaceProposer.decide` adapter — stops the optimization loop the moment
+ * the e-process decides the loop has produced a real improvement, instead of
+ * always running `maxGenerations`.
+ *
+ * Stream: for each generation g ≥ 1, the per-scenario composite deltas of
+ * generation g's top candidate vs the generation-0 top candidate (the
+ * incumbent the loop set out to beat), paired by scenarioId. H0: no proposed
+ * surface improves any scenario's expected composite over the incumbent —
+ * under it every delta has conditional mean ≤ 0 and the e-process is valid.
+ * Once wealth ≥ 1/alpha the loop stops and hands the winner to the promotion
+ * gate (which re-scores on HELD-OUT data — this adapter only spends the
+ * exploration budget, it never promotes).
+ *
+ * Honesty caveats: (1) the incumbent's scores are measured once and shared
+ * across all generations' deltas, so type-I control is exact only insofar as
+ * those scores approximate the incumbent's true per-scenario means (more reps
+ * → tighter); (2) an UNDECIDED process never stops the loop — absence of a
+ * crossing is NOT evidence of no effect, so the loop simply runs its normal
+ * course. Calling the adapter repeatedly with a growing history consumes each
+ * generation exactly once (re-feeding an already-seen record would double-count
+ * evidence).
+ */
+export declare function sequentialDecide(options?: SequentialDecideOptions): SequentialDecideFn;
+//# sourceMappingURL=sequential.d.ts.map

package/dist/campaign/gates/sequential.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequential.d.ts","sourceRoot":"","sources":["../../../src/campaign/gates/sequential.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAGH,OAAO,EAAgB,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAC1E,OAAO,EAAE,KAAK,aAAa,EAAwB,MAAM,kBAAkB,CAAA;AAC3E,OAAO,KAAK,EAAE,IAAI,EAA2B,gBAAgB,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAGzF,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,UAAU,GAAG,mBAAmB,CAAA;AAE7E,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,kBAAkB,CAAA;IAC5B,uDAAuD;IACvD,MAAM,EAAE,MAAM,CAAA;IACd,qCAAqC;IACrC,CAAC,EAAE,MAAM,CAAA;IACT;mEAC+D;IAC/D,MAAM,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,2BAA2B;IAC1C;4DACwD;IACxD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd;;qBAEiB;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb;8DAC0D;IAC1D,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,2DAA2D;IAC3D,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;uEAEmE;IACnE,KAAK,CAAC,EAAE,MAAM,CAAA;IACd;iDAC6C;IAC7C,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;+EAC2E;IAC3E,eAAe,CAAC,EAAE,cAAc,CAAA;IAChC,yCAAyC;IACzC,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,oBAAoB,CAAC,SAAS,GAAG,OAAO,EAAE,SAAS,SAAS,QAAQ,GAAG,QAAQ,CAC9F,SAAQ,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC;IAClC;;;;;;iBAMa;IACb,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,qBAAqB,CAAA;IAC7C,gDAAgD;IAChD,KAAK,IAAI,aAAa,GAAG;QAAE,QAAQ,EAAE,kBAAkB,CAAA;KAAE,CAAA;CAC1D;AA2LD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,GAAG,OAAO,EAAE,SAAS,SAAS,QAAQ,GAAG,QAAQ,EAC7F,OAAO,EAAE,2BAA2B,GACnC,oBAAoB,CAAC,SAAS,EAAE,SAAS,CAAC,CA0E5C;AAED,MAAM,WAAW,uBAAuB;IACtC,+DAA+D;IAC/D,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,+DAA+D;IAC/D,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,2DAA2D;IAC3D,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,0DAA0D;IAC1D,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,gBAAgB,EAAE,CAAA;KAAE,GAAG;QAAE,IAAI,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAC3E,+EAA+E;IAC/E,KAAK,IAAI,aAAa,CAAA;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,GAAE,uBAA4B,GAAG,kBAAkB,CAuE1F"}

package/dist/campaign/gates/sequential.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sequential.test.d.ts.map

package/dist/campaign/gates/sequential.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequential.test.d.ts","sourceRoot":"","sources":["../../../src/campaign/gates/sequential.test.ts"],"names":[],"mappings":""}