textopt 0.0.0

package/dist/simba/index.d.cts

@@ -0,0 +1,289 @@
+import { n as Candidate, t as Adapter, u as TextModel } from "../types-CWv4IQFF.cjs";
+import { n as EvaluationCache, t as CachedScore } from "../cache-CuSo0NJ8.cjs";
+import { t as Rng } from "../rng-BR5MOedA.cjs";
+import { r as DemoRenderer } from "../demos-BTuzFNsp.cjs";
+import { n as OptimizerResult, r as OptimizerTask, s as EvaluationEvent, t as Optimizer } from "../optimizer-B7SpRwl7.cjs";
+import { t as BatchSampler } from "../sampling-axOwfZf5.cjs";
+//#region src/simba/advice.d.ts
+interface AdviceTrajectory<Output = unknown> {
+  output: Output;
+  score: number;
+  feedback?: string;
+}
+interface AdvicePromptArgs<Datum = unknown, Output = unknown> {
+  /** Components the advice is wanted for, named so each can be addressed. */
+  components: readonly string[];
+  input: Datum;
+  /** The higher scoring run of this instance, when there is one to contrast. */
+  better?: AdviceTrajectory<Output>;
+  /** The lower scoring run of this instance, when there is one to contrast. */
+  worse?: AdviceTrajectory<Output>;
+}
+type AdvicePromptBuilder<Datum = unknown, Output = unknown> = (args: AdvicePromptArgs<Datum, Output>) => string;
+/**
+ * Adapted from SIMBA's `OfferFeedback` signature (Opsahl-Ong et al.'s DSPy).
+ *
+ * The framing that matters is "build up experience": the component will not
+ * see this instance again, so advice that only fixes this one input is wasted.
+ * Contrasting two runs of the *same* input is what makes that possible — the
+ * inputs are held constant, so the difference in reward is attributable to the
+ * behaviour rather than to the instance being easier.
+ */
+declare function buildAdvicePrompt<Datum, Output>(args: AdvicePromptArgs<Datum, Output>): string;
+/**
+ * Read the per-component advice out of the model's response, ignoring anything
+ * written around it. A component the model had nothing to say about is absent
+ * rather than empty, so the caller appends nothing instead of appending noise.
+ */
+declare function parseAdvice(response: string): Record<string, string>;
+//#endregion
+//#region src/simba/optimize.d.ts
+/**
+ * How a candidate is mutated. `appendDemo` adds a rollout the metric already
+ * rewarded; `appendRule` asks a model to say what the winning run did
+ * differently and writes that into the instruction.
+ */
+type SimbaStrategy = "appendDemo" | "appendRule";
+interface SimbaFinalist<K extends string = string> {
+  candidate: Candidate<K>;
+  /** Mean over the full validation set, which is what selection is decided on. */
+  score: number;
+  /** Which step produced it; 0 is the seed. */
+  step: number;
+}
+interface SimbaConfig {
+  /** Instances per step. Default 32. */
+  minibatchSize?: number;
+  /** Programs sampled per step, and candidates built from them. Default 6. */
+  candidates?: number;
+  /** Steps to run. Default 8. */
+  maxSteps?: number;
+  /** Demos a candidate may hold before the loop starts dropping them. Default 4. */
+  maxDemos?: number;
+  /** Sharpness of the pick between programs when sampling trajectories. */
+  samplingTemperature?: number;
+  /** Sharpness of the pick between programs when choosing what to mutate. */
+  candidateTemperature?: number;
+  /** Mutations to draw from. Defaults to both, or to rules alone with no demo component. */
+  strategies?: readonly SimbaStrategy[];
+  /**
+   * Advice calls the run may make. Unset lets the rollout budget bound them,
+   * which it does only loosely: a step spends a bounded number of rollouts and
+   * up to one advice call per instance in its minibatch, and the advice model
+   * is usually the expensive one. Once spent, `appendDemo` carries the run on
+   * alone, or the run stops if it was the only mutation enabled.
+   */
+  maxReflectionCalls?: number;
+  seed?: number;
+  trackBestOutputs?: boolean;
+  checkpointCache?: boolean;
+}
+/**
+ * Everything needed to continue a run: the program pool with its observed
+ * scores, the step winners, and the budget already spent. Plain JSON — persist
+ * it and hand it back as `resumeFrom`.
+ */
+interface SimbaSnapshot {
+  version: 1;
+  fingerprint: string;
+  programs: Candidate[];
+  /** Every minibatch mean observed for each program, in the order observed. */
+  programScores: number[][];
+  winners: {
+    candidate: Candidate;
+    step: number;
+  }[];
+  step: number;
+  metricCalls: number;
+  reflectionCalls: number;
+  cacheHits: number;
+  rngState: number;
+  sampler?: unknown;
+  cache?: [string, CachedScore][];
+}
+interface SimbaTask<Datum, Trajectory = unknown, Output = unknown, K extends string = string> extends OptimizerTask<Datum, Trajectory, Output, K> {
+  /**
+   * The base adapter. SIMBA reads outputs, scores and feedback and builds its
+   * own evidence, so unlike GEPA it needs no `makeReflectiveDataset`.
+   */
+  adapter: Adapter<Datum, Trajectory, Output, NoInfer<K>>;
+  /** Writes the advice `appendRule` appends. Unused when only demos are appended. */
+  reflect?: TextModel;
+  /** Components holding few-shot demo blocks. Empty disables `appendDemo`. */
+  demoComponents?: readonly NoInfer<K>[];
+  /** Components advice is appended to. Defaults to every non-demo component. */
+  instructionComponents?: readonly NoInfer<K>[];
+  renderDemo?: DemoRenderer<NoInfer<Datum>, NoInfer<Output>>;
+  buildAdvicePrompt?: AdvicePromptBuilder<NoInfer<Datum>, NoInfer<Output>>;
+  sampler?: BatchSampler<NoInfer<Datum>>;
+  instanceId?: (args: {
+    datum: NoInfer<Datum>;
+    index: number;
+  }) => string;
+  cache?: EvaluationCache | false;
+  onEvent?: (event: SimbaEvent<NoInfer<K>>) => void;
+  onCheckpoint?: (snapshot: SimbaSnapshot) => void | Promise<void>;
+  resumeFrom?: SimbaSnapshot;
+}
+type SimbaStopReason = "budgetExhausted" | "costExhausted" | "deadlineReached" | "reflectionBudgetExhausted" | "maxSteps" | "aborted";
+type SimbaEvent<K extends string = string> = {
+  type: "start";
+  components: K[];
+  validationSetSize: number;
+} | ({
+  type: "evaluation";
+} & EvaluationEvent) | {
+  type: "stepStart";
+  step: number;
+  poolSize: number;
+} | {
+  type: "candidate";
+  step: number;
+  strategy: SimbaStrategy;
+  /** The program it was mutated from; 0 is the seed. */
+  sourceProgram: number;
+  minibatchScore: number;
+} | {
+  type: "error";
+  step: number;
+  err: unknown;
+} | {
+  type: "finish";
+  reason: SimbaStopReason;
+  bestScore: number;
+  metricCalls: number;
+  testScore?: number;
+};
+interface SimbaResult<K extends string = string, Output = unknown> extends OptimizerResult<K, SimbaStopReason, Output> {
+  /** The seed's own validation score, so the lift the run bought is readable. */
+  seedScore: number;
+  steps: number;
+  /** The step winners scored on the full validation set, best first. */
+  finalists: SimbaFinalist<K>[];
+  reflectionCalls: number;
+  cacheHits: number;
+  snapshot: SimbaSnapshot;
+}
+/**
+ * SIMBA — stochastic introspective mini-batch ascent.
+ *
+ * Run several programs over the same minibatch, find the instances they
+ * disagree about most, and mutate toward whatever the winning run did. The
+ * disagreement is the point: an instance one program solved and another failed
+ * is a controlled experiment with the input held fixed, so the difference in
+ * reward is attributable to behaviour rather than to difficulty. GEPA reflects
+ * on failures; SIMBA reflects on the *contrast* between a success and a failure
+ * of the same input, which is a strictly stronger signal when it exists — and
+ * costs a pool of programs to produce.
+ *
+ * Two mutations, drawn at random per instance: append a demonstration the
+ * metric already rewarded, or ask a model what the better run did differently
+ * and append that as a rule. Neither replaces text, so a candidate accumulates;
+ * demos are dropped at a Poisson rate to keep the block from crowding out
+ * everything else.
+ *
+ * Ported from DSPy's SIMBA, with two deliberate changes. First, a trajectory
+ * sample runs one program across the whole minibatch rather than resampling a
+ * program per instance: the adapter here owns decoding, so there is no
+ * temperature knob to vary, and the variability comes from the program pool
+ * instead. Second, the percentile guards are strict rather than inclusive — on
+ * a step where every rollout ties, an inclusive guard blocks every mutation and
+ * the run does nothing at all, which is the one case where the guard's own
+ * premise does not hold.
+ */
+declare class SimbaOptimizer implements Optimizer<SimbaStopReason> {
+  #private;
+  constructor(config?: SimbaConfig);
+  optimize<Datum, Trajectory = unknown, Output = unknown, const K extends string = string>(task: SimbaTask<Datum, Trajectory, Output, K>): Promise<SimbaResult<K, Output>>;
+}
+//#endregion
+//#region src/simba/strategies.d.ts
+/** One sample of one instance: which program produced it, and how it scored. */
+interface SimbaRollout<Output = unknown> {
+  programIndex: number;
+  score: number;
+  output?: Output;
+  feedback?: string;
+}
+/**
+ * Every sample of one training instance, sorted best first, with the spread
+ * that decides whether the instance is worth learning from.
+ */
+interface SimbaBucket<Datum = unknown, Output = unknown> {
+  index: number;
+  datum: Datum;
+  rollouts: SimbaRollout<Output>[];
+  maxToMinGap: number;
+  maxScore: number;
+  maxToAvgGap: number;
+}
+interface SimbaSample<Output = unknown> {
+  programIndex: number;
+  scores: readonly number[];
+  outputs?: readonly (Output | undefined)[];
+  feedback?: readonly string[];
+}
+/**
+ * Group the step's samples by instance and rank the instances by how much the
+ * programs disagreed about them.
+ *
+ * Disagreement is the signal SIMBA runs on. An instance every program gets
+ * right teaches nothing, and one every program gets wrong is usually beyond
+ * the reach of a prompt edit; the instructive ones are where one program
+ * succeeded and another failed, because the pair is a controlled experiment
+ * the reflection model can read directly.
+ *
+ * Ranked on the max-to-min gap first, then the best score, then the max-to-avg
+ * gap: widest disagreement first, ties broken toward instances where something
+ * actually worked, since a bucket whose best rollout is bad has no success to
+ * generalize from.
+ */
+declare function buildBuckets<Datum, Output>(args: {
+  batch: readonly Datum[];
+  samples: readonly SimbaSample<Output>[];
+}): SimbaBucket<Datum, Output>[];
+/**
+ * Linear-interpolated percentile, matching numpy's default so the thresholds
+ * behave the way the reference implementation's do.
+ */
+declare function percentile(values: readonly number[], p: number): number;
+/**
+ * Softmax weights over program scores, for picking which program to mutate
+ * next. Shifted by the maximum before exponentiating — the same distribution,
+ * but a score scale the caller chose freely cannot overflow it.
+ */
+declare function softmaxWeights(scores: readonly number[], temperature: number): number[];
+/**
+ * The `k` highest scoring programs, with the baseline forced into the pool.
+ *
+ * Keeping the baseline is what makes the search recoverable: every candidate
+ * descends from a program already in the pool, so a pool that has drifted into
+ * a bad region has nothing left to climb back from.
+ */
+declare function topKPlusBaseline(args: {
+  scores: readonly number[];
+  k: number;
+}): number[];
+/**
+ * A Poisson draw by Knuth's method, used to decide how many demonstrations to
+ * drop before a mutation. Random rather than fixed so a candidate can shed a
+ * demo that is no longer earning its place — nothing else in the loop ever
+ * removes one, and a block that only grows eventually crowds out the
+ * instruction it was meant to support.
+ */
+declare function samplePoisson(rng: Rng, lambda: number): number;
+/**
+ * Positions spread evenly across a sequence, first and last included.
+ *
+ * The step winners are held back and only a sample of them is scored on the
+ * full validation set at the end, because scoring every one of them costs more
+ * than the search did. Sampling evenly rather than taking the last few keeps
+ * early winners in the running: minibatch scores are noisy, and the run's
+ * genuine best is often not its most recent.
+ */
+declare function evenlySpacedIndices(args: {
+  length: number;
+  count: number;
+}): number[];
+//#endregion
+export { type AdvicePromptArgs, type AdvicePromptBuilder, type AdviceTrajectory, type SimbaBucket, type SimbaConfig, type SimbaEvent, type SimbaFinalist, SimbaOptimizer, type SimbaResult, type SimbaRollout, type SimbaSample, type SimbaSnapshot, type SimbaStopReason, type SimbaStrategy, type SimbaTask, buildAdvicePrompt, buildBuckets, evenlySpacedIndices, parseAdvice, percentile, samplePoisson, softmaxWeights, topKPlusBaseline };

package/dist/simba/index.d.mts

@@ -0,0 +1,289 @@
+import { n as Candidate, t as Adapter, u as TextModel } from "../types-CWv4IQFF.mjs";
+import { n as EvaluationCache, t as CachedScore } from "../cache-CuSo0NJ8.mjs";
+import { t as Rng } from "../rng-BR5MOedA.mjs";
+import { r as DemoRenderer } from "../demos-B0pVQjYC.mjs";
+import { n as OptimizerResult, r as OptimizerTask, s as EvaluationEvent, t as Optimizer } from "../optimizer-DqCoth_w.mjs";
+import { t as BatchSampler } from "../sampling-DFo_7RNJ.mjs";
+//#region src/simba/advice.d.ts
+interface AdviceTrajectory<Output = unknown> {
+  output: Output;
+  score: number;
+  feedback?: string;
+}
+interface AdvicePromptArgs<Datum = unknown, Output = unknown> {
+  /** Components the advice is wanted for, named so each can be addressed. */
+  components: readonly string[];
+  input: Datum;
+  /** The higher scoring run of this instance, when there is one to contrast. */
+  better?: AdviceTrajectory<Output>;
+  /** The lower scoring run of this instance, when there is one to contrast. */
+  worse?: AdviceTrajectory<Output>;
+}
+type AdvicePromptBuilder<Datum = unknown, Output = unknown> = (args: AdvicePromptArgs<Datum, Output>) => string;
+/**
+ * Adapted from SIMBA's `OfferFeedback` signature (Opsahl-Ong et al.'s DSPy).
+ *
+ * The framing that matters is "build up experience": the component will not
+ * see this instance again, so advice that only fixes this one input is wasted.
+ * Contrasting two runs of the *same* input is what makes that possible — the
+ * inputs are held constant, so the difference in reward is attributable to the
+ * behaviour rather than to the instance being easier.
+ */
+declare function buildAdvicePrompt<Datum, Output>(args: AdvicePromptArgs<Datum, Output>): string;
+/**
+ * Read the per-component advice out of the model's response, ignoring anything
+ * written around it. A component the model had nothing to say about is absent
+ * rather than empty, so the caller appends nothing instead of appending noise.
+ */
+declare function parseAdvice(response: string): Record<string, string>;
+//#endregion
+//#region src/simba/optimize.d.ts
+/**
+ * How a candidate is mutated. `appendDemo` adds a rollout the metric already
+ * rewarded; `appendRule` asks a model to say what the winning run did
+ * differently and writes that into the instruction.
+ */
+type SimbaStrategy = "appendDemo" | "appendRule";
+interface SimbaFinalist<K extends string = string> {
+  candidate: Candidate<K>;
+  /** Mean over the full validation set, which is what selection is decided on. */
+  score: number;
+  /** Which step produced it; 0 is the seed. */
+  step: number;
+}
+interface SimbaConfig {
+  /** Instances per step. Default 32. */
+  minibatchSize?: number;
+  /** Programs sampled per step, and candidates built from them. Default 6. */
+  candidates?: number;
+  /** Steps to run. Default 8. */
+  maxSteps?: number;
+  /** Demos a candidate may hold before the loop starts dropping them. Default 4. */
+  maxDemos?: number;
+  /** Sharpness of the pick between programs when sampling trajectories. */
+  samplingTemperature?: number;
+  /** Sharpness of the pick between programs when choosing what to mutate. */
+  candidateTemperature?: number;
+  /** Mutations to draw from. Defaults to both, or to rules alone with no demo component. */
+  strategies?: readonly SimbaStrategy[];
+  /**
+   * Advice calls the run may make. Unset lets the rollout budget bound them,
+   * which it does only loosely: a step spends a bounded number of rollouts and
+   * up to one advice call per instance in its minibatch, and the advice model
+   * is usually the expensive one. Once spent, `appendDemo` carries the run on
+   * alone, or the run stops if it was the only mutation enabled.
+   */
+  maxReflectionCalls?: number;
+  seed?: number;
+  trackBestOutputs?: boolean;
+  checkpointCache?: boolean;
+}
+/**
+ * Everything needed to continue a run: the program pool with its observed
+ * scores, the step winners, and the budget already spent. Plain JSON — persist
+ * it and hand it back as `resumeFrom`.
+ */
+interface SimbaSnapshot {
+  version: 1;
+  fingerprint: string;
+  programs: Candidate[];
+  /** Every minibatch mean observed for each program, in the order observed. */
+  programScores: number[][];
+  winners: {
+    candidate: Candidate;
+    step: number;
+  }[];
+  step: number;
+  metricCalls: number;
+  reflectionCalls: number;
+  cacheHits: number;
+  rngState: number;
+  sampler?: unknown;
+  cache?: [string, CachedScore][];
+}
+interface SimbaTask<Datum, Trajectory = unknown, Output = unknown, K extends string = string> extends OptimizerTask<Datum, Trajectory, Output, K> {
+  /**
+   * The base adapter. SIMBA reads outputs, scores and feedback and builds its
+   * own evidence, so unlike GEPA it needs no `makeReflectiveDataset`.
+   */
+  adapter: Adapter<Datum, Trajectory, Output, NoInfer<K>>;
+  /** Writes the advice `appendRule` appends. Unused when only demos are appended. */
+  reflect?: TextModel;
+  /** Components holding few-shot demo blocks. Empty disables `appendDemo`. */
+  demoComponents?: readonly NoInfer<K>[];
+  /** Components advice is appended to. Defaults to every non-demo component. */
+  instructionComponents?: readonly NoInfer<K>[];
+  renderDemo?: DemoRenderer<NoInfer<Datum>, NoInfer<Output>>;
+  buildAdvicePrompt?: AdvicePromptBuilder<NoInfer<Datum>, NoInfer<Output>>;
+  sampler?: BatchSampler<NoInfer<Datum>>;
+  instanceId?: (args: {
+    datum: NoInfer<Datum>;
+    index: number;
+  }) => string;
+  cache?: EvaluationCache | false;
+  onEvent?: (event: SimbaEvent<NoInfer<K>>) => void;
+  onCheckpoint?: (snapshot: SimbaSnapshot) => void | Promise<void>;
+  resumeFrom?: SimbaSnapshot;
+}
+type SimbaStopReason = "budgetExhausted" | "costExhausted" | "deadlineReached" | "reflectionBudgetExhausted" | "maxSteps" | "aborted";
+type SimbaEvent<K extends string = string> = {
+  type: "start";
+  components: K[];
+  validationSetSize: number;
+} | ({
+  type: "evaluation";
+} & EvaluationEvent) | {
+  type: "stepStart";
+  step: number;
+  poolSize: number;
+} | {
+  type: "candidate";
+  step: number;
+  strategy: SimbaStrategy;
+  /** The program it was mutated from; 0 is the seed. */
+  sourceProgram: number;
+  minibatchScore: number;
+} | {
+  type: "error";
+  step: number;
+  err: unknown;
+} | {
+  type: "finish";
+  reason: SimbaStopReason;
+  bestScore: number;
+  metricCalls: number;
+  testScore?: number;
+};
+interface SimbaResult<K extends string = string, Output = unknown> extends OptimizerResult<K, SimbaStopReason, Output> {
+  /** The seed's own validation score, so the lift the run bought is readable. */
+  seedScore: number;
+  steps: number;
+  /** The step winners scored on the full validation set, best first. */
+  finalists: SimbaFinalist<K>[];
+  reflectionCalls: number;
+  cacheHits: number;
+  snapshot: SimbaSnapshot;
+}
+/**
+ * SIMBA — stochastic introspective mini-batch ascent.
+ *
+ * Run several programs over the same minibatch, find the instances they
+ * disagree about most, and mutate toward whatever the winning run did. The
+ * disagreement is the point: an instance one program solved and another failed
+ * is a controlled experiment with the input held fixed, so the difference in
+ * reward is attributable to behaviour rather than to difficulty. GEPA reflects
+ * on failures; SIMBA reflects on the *contrast* between a success and a failure
+ * of the same input, which is a strictly stronger signal when it exists — and
+ * costs a pool of programs to produce.
+ *
+ * Two mutations, drawn at random per instance: append a demonstration the
+ * metric already rewarded, or ask a model what the better run did differently
+ * and append that as a rule. Neither replaces text, so a candidate accumulates;
+ * demos are dropped at a Poisson rate to keep the block from crowding out
+ * everything else.
+ *
+ * Ported from DSPy's SIMBA, with two deliberate changes. First, a trajectory
+ * sample runs one program across the whole minibatch rather than resampling a
+ * program per instance: the adapter here owns decoding, so there is no
+ * temperature knob to vary, and the variability comes from the program pool
+ * instead. Second, the percentile guards are strict rather than inclusive — on
+ * a step where every rollout ties, an inclusive guard blocks every mutation and
+ * the run does nothing at all, which is the one case where the guard's own
+ * premise does not hold.
+ */
+declare class SimbaOptimizer implements Optimizer<SimbaStopReason> {
+  #private;
+  constructor(config?: SimbaConfig);
+  optimize<Datum, Trajectory = unknown, Output = unknown, const K extends string = string>(task: SimbaTask<Datum, Trajectory, Output, K>): Promise<SimbaResult<K, Output>>;
+}
+//#endregion
+//#region src/simba/strategies.d.ts
+/** One sample of one instance: which program produced it, and how it scored. */
+interface SimbaRollout<Output = unknown> {
+  programIndex: number;
+  score: number;
+  output?: Output;
+  feedback?: string;
+}
+/**
+ * Every sample of one training instance, sorted best first, with the spread
+ * that decides whether the instance is worth learning from.
+ */
+interface SimbaBucket<Datum = unknown, Output = unknown> {
+  index: number;
+  datum: Datum;
+  rollouts: SimbaRollout<Output>[];
+  maxToMinGap: number;
+  maxScore: number;
+  maxToAvgGap: number;
+}
+interface SimbaSample<Output = unknown> {
+  programIndex: number;
+  scores: readonly number[];
+  outputs?: readonly (Output | undefined)[];
+  feedback?: readonly string[];
+}
+/**
+ * Group the step's samples by instance and rank the instances by how much the
+ * programs disagreed about them.
+ *
+ * Disagreement is the signal SIMBA runs on. An instance every program gets
+ * right teaches nothing, and one every program gets wrong is usually beyond
+ * the reach of a prompt edit; the instructive ones are where one program
+ * succeeded and another failed, because the pair is a controlled experiment
+ * the reflection model can read directly.
+ *
+ * Ranked on the max-to-min gap first, then the best score, then the max-to-avg
+ * gap: widest disagreement first, ties broken toward instances where something
+ * actually worked, since a bucket whose best rollout is bad has no success to
+ * generalize from.
+ */
+declare function buildBuckets<Datum, Output>(args: {
+  batch: readonly Datum[];
+  samples: readonly SimbaSample<Output>[];
+}): SimbaBucket<Datum, Output>[];
+/**
+ * Linear-interpolated percentile, matching numpy's default so the thresholds
+ * behave the way the reference implementation's do.
+ */
+declare function percentile(values: readonly number[], p: number): number;
+/**
+ * Softmax weights over program scores, for picking which program to mutate
+ * next. Shifted by the maximum before exponentiating — the same distribution,
+ * but a score scale the caller chose freely cannot overflow it.
+ */
+declare function softmaxWeights(scores: readonly number[], temperature: number): number[];
+/**
+ * The `k` highest scoring programs, with the baseline forced into the pool.
+ *
+ * Keeping the baseline is what makes the search recoverable: every candidate
+ * descends from a program already in the pool, so a pool that has drifted into
+ * a bad region has nothing left to climb back from.
+ */
+declare function topKPlusBaseline(args: {
+  scores: readonly number[];
+  k: number;
+}): number[];
+/**
+ * A Poisson draw by Knuth's method, used to decide how many demonstrations to
+ * drop before a mutation. Random rather than fixed so a candidate can shed a
+ * demo that is no longer earning its place — nothing else in the loop ever
+ * removes one, and a block that only grows eventually crowds out the
+ * instruction it was meant to support.
+ */
+declare function samplePoisson(rng: Rng, lambda: number): number;
+/**
+ * Positions spread evenly across a sequence, first and last included.
+ *
+ * The step winners are held back and only a sample of them is scored on the
+ * full validation set at the end, because scoring every one of them costs more
+ * than the search did. Sampling evenly rather than taking the last few keeps
+ * early winners in the running: minibatch scores are noisy, and the run's
+ * genuine best is often not its most recent.
+ */
+declare function evenlySpacedIndices(args: {
+  length: number;
+  count: number;
+}): number[];
+//#endregion
+export { type AdvicePromptArgs, type AdvicePromptBuilder, type AdviceTrajectory, type SimbaBucket, type SimbaConfig, type SimbaEvent, type SimbaFinalist, SimbaOptimizer, type SimbaResult, type SimbaRollout, type SimbaSample, type SimbaSnapshot, type SimbaStopReason, type SimbaStrategy, type SimbaTask, buildAdvicePrompt, buildBuckets, evenlySpacedIndices, parseAdvice, percentile, samplePoisson, softmaxWeights, topKPlusBaseline };