@yipe/dice 0.10.0 → 0.12.0

package/dist/turn/effects.d.ts

@@ -0,0 +1,114 @@
+import type { DCBuilder } from "../builder/dc.js";
+import type { GrantSpec, RiderOptions, SubstituteSpec } from "./types.js";
+/**
+ * A payload transform a trigger verb accepts, as opposed to damage (a rider).
+ * Built only by a named factory such as {@link keepBestDamage}, so the wire kind
+ * never appears at a call site. Immutable: every method returns a new value.
+ */
+export interface Transform {
+    readonly kind: "transform";
+    /**
+     * Spend only when the base payload total (dice plus the payload's own flat
+     * bonus, excluding separate-damage channels) is below `threshold` in the mode
+     * that landed; otherwise hold for the next watched attack. The threshold
+     * applies only while a later watched step can still land in the current turn
+     * state; when none can, any landing spends, since holding is worth nothing.
+     * A single number applies to both modes, which for a crit's doubled dice
+     * usually means "hold" — pass `{ hit, crit }` to set each.
+     *
+     * Compares the payload's own values, so it works on any payload: a builder, a
+     * parsed string or a bare `PMF`.
+     */
+    ifBelow(threshold: number | {
+        hit: number;
+        crit: number;
+    }): Transform;
+    /**
+     * Spend by backward induction over the remaining steps. Not supported in this
+     * release: throws `TurnSpecError("unsupported-policy")`.
+     */
+    optimally(): Transform;
+}
+/**
+ * Roll the watched attack's whole base payload again and keep the better total —
+ * once per turn. Pass it to `Turn.onFirstHit`:
+ *
+ * ```ts
+ * turn([sword, sword]).onFirstHit(keepBestDamage());
+ * ```
+ *
+ * The transform reads the attack's own damage, so no dice are restated. It never
+ * touches `plusSeparateDamage` channels, `every-hit` rider damage, or the miss
+ * branch, and a crit transforms the crit payload (the already-doubled dice).
+ *
+ * **Policy.** The default spends on the first watched attack that lands, whatever
+ * it rolled. That is a named policy, not optimal play: a player who sees a high
+ * roll holds the reroll for a later attack. The figure is therefore a lower bound.
+ * Two `d20+5` attacks against AC 12 dealing `2d6+3` score 15.9849 under this
+ * policy against 16.1889 for the optimal hold/use policy (14.7000 without the
+ * transform); {@link Transform.ifBelow} with `{ hit: 10, crit: 18 }` reaches the
+ * optimum on that turn.
+ *
+ * **Ties.** When the fresh total ties the original, the original roll is kept. The
+ * total is the same either way, but a `dice-match` trigger reading the attack sees
+ * the kept dice's match status: a player who would take a tied roll because its
+ * dice matched is not modelled.
+ */
+export declare function keepBestDamage(): Transform;
+/** True for a {@link Transform} built by a factory in this module. */
+export declare function isTransform(value: unknown): value is Transform;
+/** The JSON-safe fields a {@link Transform} contributes to a {@link SubstituteSpec}. */
+export declare function substituteFields(transform: Transform): Pick<SubstituteSpec, "substitute" | "policy">;
+/**
+ * What a grant does to the attack rolls that read it, before it has a lifetime.
+ * Not yet a {@link Grant}: a trigger verb refuses it at compile time, so a
+ * forgotten lifetime is a type error rather than a silent default. Immutable.
+ */
+export interface Modifiers {
+    /** Adds advantage; repeating a modifier is a no-op. */
+    advantage(): Modifiers;
+    disadvantage(): Modifiers;
+    /** Every landing attack is a crit; a natural 1 still misses. */
+    critOnHit(): Modifiers;
+    /** Consumed by the next attack roll that reads it, hit or miss. */
+    untilNextAttack(): Grant;
+    /** Lasts for the rest of the turn. */
+    untilEndOfTurn(): Grant;
+}
+/**
+ * A modifier with a lifetime: the only thing a trigger verb accepts besides damage
+ * and transforms. Pass several in an array to have one outcome (and one save)
+ * apply them together. Immutable.
+ */
+export interface Grant {
+    readonly kind: "grant";
+    /**
+     * The attack ids, attack-shaped rider ids or tags that read it. Omitted, every
+     * later attack roll does. Naming nothing that comes after the condition's
+     * sources is `unknown-id`.
+     */
+    to(...targets: readonly string[]): Grant;
+}
+/** Advantage on the attack rolls that read the grant: `advantage().untilNextAttack()`. */
+export declare function advantage(): Modifiers;
+/** Disadvantage on the attack rolls that read the grant; cancels an advantage. */
+export declare function disadvantage(): Modifiers;
+/** Every landing attack that reads the grant is a crit: `critOnHit().untilEndOfTurn()`. */
+export declare function critOnHit(): Modifiers;
+/** True for a {@link Grant} built by a factory in this module. */
+export declare function isGrant(value: unknown): value is Grant;
+/** The JSON-safe form of a {@link Grant}. */
+export declare function grantSpec(grant: Grant): GrantSpec;
+/**
+ * Rider options plus what gates a call's grants. The gate applies to grants only:
+ * damage passed in the same call lands whatever the save does.
+ */
+export interface ConditionOptions extends RiderOptions {
+    /** The target's save; its P(fail) is the chance the grants take. */
+    save?: DCBuilder;
+    /** In `[0, 1]`; mutually exclusive with `save`. */
+    chance?: number;
+    /** Grants applied on the other branch: the save succeeded (or `1 - chance`). */
+    onSave?: Grant | readonly Grant[];
+}
+//# sourceMappingURL=effects.d.ts.map

package/dist/turn/effects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effects.d.ts","sourceRoot":"","sources":["../../src/turn/effects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAoB,cAAc,EAAE,MAAM,SAAS,CAAC;AAGzF;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAC;IACtE;;;OAGG;IACH,SAAS,IAAI,SAAS,CAAC;CACxB;AA4BD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,cAAc,IAAI,SAAS,CAE1C;AAED,sEAAsE;AACtE,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,CAE9D;AAED,wFAAwF;AACxF,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,SAAS,GACnB,IAAI,CAAC,cAAc,EAAE,YAAY,GAAG,QAAQ,CAAC,CAG/C;AAED;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACxB,uDAAuD;IACvD,SAAS,IAAI,SAAS,CAAC;IACvB,YAAY,IAAI,SAAS,CAAC;IAC1B,gEAAgE;IAChE,SAAS,IAAI,SAAS,CAAC;IACvB,mEAAmE;IACnE,eAAe,IAAI,KAAK,CAAC;IACzB,sCAAsC;IACtC,cAAc,IAAI,KAAK,CAAC;CACzB;AAED;;;;GAIG;AACH,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB;;;;OAIG;IACH,EAAE,CAAC,GAAG,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,KAAK,CAAC;CAC1C;AAsCD,0FAA0F;AAC1F,wBAAgB,SAAS,IAAI,SAAS,CAErC;AAED,kFAAkF;AAClF,wBAAgB,YAAY,IAAI,SAAS,CAExC;AAED,2FAA2F;AAC3F,wBAAgB,SAAS,IAAI,SAAS,CAErC;AAED,kEAAkE;AAClE,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,KAAK,CAEtD;AAED,6CAA6C;AAC7C,wBAAgB,SAAS,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,CAEjD;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAiB,SAAQ,YAAY;IACpD,oEAAoE;IACpE,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,mDAAmD;IACnD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gFAAgF;IAChF,MAAM,CAAC,EAAE,KAAK,GAAG,SAAS,KAAK,EAAE,CAAC;CACnC"}

package/dist/turn/index.d.ts

@@ -1,3 +1,5 @@
-export * from "./turn.js";
+export { bounce, turn, Turn } from "./turn.js";
+export { advantage, critOnHit, disadvantage, keepBestDamage } from "./effects.js";
+export type { ConditionOptions, Grant, Modifiers, Transform } from "./effects.js";
 export * from "./types.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/turn/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/turn/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/turn/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC/E,YAAY,EAAE,gBAAgB,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC/E,cAAc,SAAS,CAAC"}

package/dist/turn/plan.d.ts

@@ -1,5 +1,8 @@
 import { PMF } from "../pmf/pmf.js";
-import type { Trigger, TurnSpec } from "./types.js";
+import type { StepOutcome } from "./state.js";
+import type { AttackTriggerOn, Trigger, TurnSpec } from "./types.js";
+/** Which payload a rider used when it fired, or `null` while it has not fired. */
+export type FireMode = "hit" | "crit" | null;
 /**
  * A resolved, validated turn: the ordered steps to walk, plus the trigger
  * groups it tracks. Building this is where every {@link TurnSpecError} is raised,
@@ -15,30 +18,112 @@ export interface TurnPlan {
     attackIds: readonly string[];
     /** Every rider id, in declaration order, including `every-hit` riders. */
     riderIds: readonly string[];
-    /** Rider id → step index, for `fireProbability` and `not-fired`. */
-    riderSteps: ReadonlyMap<string, number>;
+    /** Every substitute id, in declaration order. */
+    substituteIds: readonly string[];
+    /**
+     * Ids of the attack-shaped `any-miss` / `first-miss` riders, in declaration
+     * order: a reroll continues the attacks it watches, so `Turn`'s chaining
+     * methods add these to a later rider's defaulted `of`. A list of several
+     * attacks is not attack-shaped, so it is never among them.
+     */
+    rerollIds: readonly string[];
+    /**
+     * Rider or substitute id → its fire slot: the index into the walk's per-state
+     * `fired` array. A rider's slot records the mode it fired in; a substitute's
+     * records the mode it was spent in. `every-hit` riders have none (see
+     * `perHitGroups`); a `first-miss` rider's several steps share one.
+     */
+    fireSlots: ReadonlyMap<string, number>;
+    slotCount: number;
     /**
      * `every-hit` rider id → the group index whose "something landed" bit answers
      * P(it fired at least once). Such riders are folded into their sources' slices
      * rather than becoming steps, so they have no step index.
      */
     perHitGroups: ReadonlyMap<string, number>;
+    /**
+     * The LAST step index (in final walk order) that reads each group, by group
+     * index — `steps.length` for a group `perHitGroups` still needs at the final
+     * collapse. Once the walk passes a group's last reader, its specific code
+     * stops discriminating any future decision, so `Turn.resolve`'s `merge` stops
+     * keying on it past that point — the dominant cost fix for a long `dice-match`
+     * chain (a group read by exactly one downstream step, the common shape, would
+     * otherwise keep splitting states for every step after that single read).
+     */
+    groupLastReadStep: readonly number[];
+    /** Every condition id, in declaration order. */
+    conditionIds: readonly string[];
+    /**
+     * The LAST step index that reads each flag bit, the twin of `groupLastReadStep`:
+     * past it the bit no longer changes any decision, so the walk drops it from the
+     * merge key. A turn with no conditions has no bits.
+     */
+    flagLastReadStep: readonly number[];
+}
+/**
+ * One outcome a step's walk convolves in: which group-state outcome it advances,
+ * whether it counts as a dice-match, whether drawing it spends the step's
+ * substitute, and the sub-mass PMF itself.
+ */
+export interface Draw {
+    outcome: StepOutcome;
+    matched: boolean;
+    spends: boolean;
+    slice: PMF;
+}
+/**
+ * The draws of one attack step under one state-dependent context. Masses sum to 1.
+ *
+ * Hit and crit expand into two draws each when the source is match-sliced (a
+ * `dice-match` trigger names it) and into more when a substitute's policy splits
+ * them into spend and hold parts; every other step walks the same three draws —
+ * hit, crit, miss — so turns without those features pay nothing extra.
+ */
+export type StepVariant = readonly Draw[];
+/**
+ * One condition, applied at one of its source steps. When the drawn outcome
+ * qualifies, the draw splits by `chance`: `grants` are set on one part, `onSave`
+ * on the other.
+ */
+export interface GrantApplication {
+    /** Index into {@link TurnPlan.conditionIds}. */
+    condition: number;
+    on: AttackTriggerOn;
+    /** Group whose pre-draw code `first-hit` / `first-miss` reads, else -1. */
+    reads: number;
+    chance: number;
+    /** Flag bits set on the `chance` branch. */
+    grants: number;
+    /** Flag bits set on the other branch. */
+    onSave: number;
+    /** Non-zero when the application is skipped once all of these bits are set. */
+    inForce: number;
+    /** Whether a later step reads one of `grants` — what `fireProbability` counts. */
+    effective: boolean;
 }
+/** Whether `outcome`, drawn in a state whose pre-draw group codes are `codes`, applies `app`. */
+export declare function grantApplies(app: GrantApplication, outcome: StepOutcome, codes: readonly number[]): boolean;
 /**
- * One step of the turn. `slices` non-null ⇒ the step rolls its own attack and
- * advances the groups listed in `updates`; null ⇒ it is pure damage whose amount
+ * One step of the turn. A non-empty `variants` ⇒ the step rolls its own attack and
+ * advances the groups listed in `updates`; empty ⇒ it is pure damage whose amount
  * depends only on the mode it fires in.
  */
 export interface Step {
     id: string;
     /** Declared attacks always fire; riders consult their trigger. */
     trigger: Trigger | null;
-    /** Outcome-labelled sub-mass PMFs, masses summing to 1. */
-    slices: {
-        hit: PMF;
-        crit: PMF;
-        miss: PMF;
-    } | null;
+    /**
+     * Every precomputed draw set for this step; index 0 is the plain one. A step with
+     * no state dependence has exactly one. Nothing is transformed inside the walk:
+     * {@link Step.select} picks one of these at the draw site.
+     */
+    variants: readonly StepVariant[];
+    /**
+     * Which variant to draw from, given the state's group codes, its fire slots with
+     * this step's own firing already recorded, and its flag bits before this step
+     * consumes any.
+     */
+    select: (codes: readonly number[], fired: readonly FireMode[], flags: number) => number;
     /** Pure-damage payloads, mass 1 each. */
     damage: {
         hit: PMF;
@@ -48,8 +133,26 @@ export interface Step {
     updates: readonly number[];
     /** Group index this step's trigger reads, or -1 for `not-fired` / always-fires. */
     reads: number;
-    /** For `not-fired`: the step index of the rider being negated. */
+    /** Fire slot this step writes when it fires, or -1 for a declared attack. */
+    slot: number;
+    /** For `not-fired`: the fire slot of the rider or substitute being negated. */
     negates: number;
+    /** Fire slot a `spends` draw sets — the watching substitute's — or -1. */
+    spendSlot: number;
+    /** `next-attack` flag bits this step reads, and so clears when it rolls. */
+    consumes: number;
+    /** Conditions this step's outcome may apply, in declaration order. */
+    grants: readonly GrantApplication[];
 }
+/**
+ * Decide whether `step` fires in state `codes`, and in which mode.
+ *
+ * Every group a trigger reads is fully determined before its own step runs
+ * (sources always precede dependents), so a trigger can be evaluated once, at
+ * its step, and again at the end for `Turn.fireProbability` — both give the
+ * same answer. The walk calls this at every step; a threshold policy's
+ * look-ahead calls it for the steps still to come.
+ */
+export declare function fireMode(step: Step, codes: readonly number[], fired: readonly FireMode[]): FireMode;
 export declare function buildPlan(spec: TurnSpec, eps?: number): TurnPlan;
 //# sourceMappingURL=plan.d.ts.map

package/dist/turn/plan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../src/turn/plan.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,KAAK,EAKV,OAAO,EACP,QAAQ,EAET,MAAM,SAAS,CAAC;AAGjB;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,SAAS,IAAI,EAAE,CAAC;IACvB,mFAAmF;IACnF,UAAU,EAAE,MAAM,CAAC;IACnB,uEAAuE;IACvE,UAAU,EAAE,SAAS,GAAG,EAAE,CAAC;IAC3B,6CAA6C;IAC7C,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,0EAA0E;IAC1E,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,oEAAoE;IACpE,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC;;;;OAIG;IACH,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC3C;AAED;;;;GAIG;AACH,MAAM,WAAW,IAAI;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,kEAAkE;IAClE,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IACxB,2DAA2D;IAC3D,MAAM,EAAE;QAAE,GAAG,EAAE,GAAG,CAAC;QAAC,IAAI,EAAE,GAAG,CAAC;QAAC,IAAI,EAAE,GAAG,CAAA;KAAE,GAAG,IAAI,CAAC;IAClD,yCAAyC;IACzC,MAAM,EAAE;QAAE,GAAG,EAAE,GAAG,CAAC;QAAC,IAAI,EAAE,GAAG,CAAA;KAAE,GAAG,IAAI,CAAC;IACvC,kDAAkD;IAClD,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,mFAAmF;IACnF,KAAK,EAAE,MAAM,CAAC;IACd,kEAAkE;IAClE,OAAO,EAAE,MAAM,CAAC;CACjB;AA6FD,wBAAgB,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,GAAE,MAAY,GAAG,QAAQ,CAoRrE"}
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../src/turn/plan.ts"],"names":[],"mappings":"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"}

package/dist/turn/state.d.ts

@@ -3,21 +3,35 @@
  *
  * A "group" is one distinct set of source ids referenced by a trigger. Everything
  * any trigger needs to know about a group is which outcome landed *first*, whether
- * anything crit, and whether anything missed — so the whole turn state is one byte
- * per group and the state space stays small (12 codes per group, ~10 reachable).
+ * anything crit, whether anything missed, whether anything's dice matched, and
+ * whether a match came from a crit — so the whole turn state stays small per group.
  *
- * Layout: `first << 2 | anyCrit << 1 | anyMiss`, where `first` is one of
- * {@link FIRST_NONE} / {@link FIRST_HIT} / {@link FIRST_CRIT}. Readers decode with
- * `code >> 2`, `code & CRIT_BIT`, `code & MISS_BIT`.
+ * Layout: `first << 2 | anyCrit << 1 | anyMiss | anyMatch << 4 | anyCritMatch << 5`,
+ * where `first` is one of {@link FIRST_NONE} / {@link FIRST_HIT} / {@link FIRST_CRIT}.
+ * Readers decode with `code >> 2 & 0b11`, `code & CRIT_BIT`, `code & MISS_BIT`,
+ * `code & MATCH_BIT`, `code & CRIT_MATCH_BIT`.
  */
 export declare const FIRST_NONE = 0;
 export declare const FIRST_HIT = 1;
 export declare const FIRST_CRIT = 2;
 export declare const CRIT_BIT = 2;
 export declare const MISS_BIT = 1;
-/** A group that has seen nothing yet: no first landing, no crit, no miss. */
+/**
+ * Bit 4 — `FIRST_CRIT` (2) shifted left by 2 is `0b1000` (bit 3), so bits 0-3 are
+ * occupied by first/crit/miss.
+ */
+export declare const MATCH_BIT = 16;
+/**
+ * Bit 5 — set with {@link MATCH_BIT} when the matching landing was a crit, so a
+ * damage-shaped `dice-match` rider doubles its dice exactly when a crit's dice
+ * matched. Max reachable code is `8|2|1|16|32 = 59`, still < 256, so `turn.ts`'s
+ * `String.fromCharCode` per-group state key is unaffected.
+ */
+export declare const CRIT_MATCH_BIT = 32;
+/** A group that has seen nothing yet: no first landing, no crit, no miss, no match. */
 export declare const START_CODE: number;
 export type StepOutcome = "hit" | "crit" | "miss";
-/** Fold one source outcome into a group's state. */
-export declare function advance(code: number, outcome: StepOutcome): number;
+/** Fold one source outcome into a group's state. `matched` only has an effect on
+ * `"hit"`/`"crit"` — a miss rolls no dice, so it can never match. */
+export declare function advance(code: number, outcome: StepOutcome, matched?: boolean): number;
 //# sourceMappingURL=state.d.ts.map

package/dist/turn/state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/turn/state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU,IAAI,CAAC;AAC5B,eAAO,MAAM,SAAS,IAAI,CAAC;AAC3B,eAAO,MAAM,UAAU,IAAI,CAAC;AAE5B,eAAO,MAAM,QAAQ,IAAI,CAAC;AAC1B,eAAO,MAAM,QAAQ,IAAI,CAAC;AAE1B,6EAA6E;AAC7E,eAAO,MAAM,UAAU,QAAkB,CAAC;AAE1C,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;AAElD,oDAAoD;AACpD,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,MAAM,CASlE"}
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/turn/state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,UAAU,IAAI,CAAC;AAC5B,eAAO,MAAM,SAAS,IAAI,CAAC;AAC3B,eAAO,MAAM,UAAU,IAAI,CAAC;AAE5B,eAAO,MAAM,QAAQ,IAAI,CAAC;AAC1B,eAAO,MAAM,QAAQ,IAAI,CAAC;AAC1B;;;GAGG;AACH,eAAO,MAAM,SAAS,KAAK,CAAC;AAC5B;;;;;GAKG;AACH,eAAO,MAAM,cAAc,KAAK,CAAC;AAEjC,uFAAuF;AACvF,eAAO,MAAM,UAAU,QAAkB,CAAC;AAE1C,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;AAElD;qEACqE;AACrE,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,UAAQ,GAAG,MAAM,CAWnF"}

package/dist/turn/turn.d.ts

@@ -1,6 +1,17 @@
 import { PMF } from "../pmf/pmf.js";
 import { DiceQuery } from "../pmf/query.js";
-import type { Attack, Rider, RiderDamage, RiderOptions, Source, TurnSpec } from "./types.js";
+import type { ConditionOptions, Grant, Transform } from "./effects.js";
+import type { Attack, AttackOptions, Damage, Rider, RiderDamage, RiderOptions, Source, TurnSpec } from "./types.js";
+/** What a trigger verb accepts: damage, grants, or both in one list. */
+type Effect = RiderDamage | Grant | readonly (Damage | Grant)[];
+/**
+ * The number of trigger groups `t` tracks and, per step, the number of distinct
+ * walk states after it. Resolves `t` if it has not been resolved yet.
+ */
+export declare function inspectTurn(t: Turn): {
+    groupCount: number;
+    stateCounts: readonly number[];
+};
 /**
  * A turn of attacks plus conditional damage riders, resolved to one **exact**
  * joint distribution.
@@ -18,8 +29,7 @@ import type { Attack, Rider, RiderDamage, RiderOptions, Source, TurnSpec } from
  */
 export declare class Turn {
     private readonly eps;
-    private readonly declaredAttacks;
-    private readonly riders;
+    private readonly state;
     private readonly plan;
     private resolved?;
     private constructor();
@@ -27,22 +37,30 @@ export declare class Turn {
      * Builds a turn from plain data, throwing {@link TurnSpecError} if it is
      * malformed. Use this from a UI, where `error.code` maps to the field state to
      * show.
+     *
+     * A rider, substitute or condition with no `of` watches every declared attack
+     * plus the attack-shaped `any-miss` / `first-miss` rerolls — for a rider, those
+     * listed before it — the same sources the chaining spelling snapshots.
      */
     static from(spec: TurnSpec, eps?: number): Turn;
+    private with;
+    /** What a chaining call's omitted `of` means: the attacks so far, plus any reroll so far. */
+    private defaultOf;
     /**
      * Appends an attack, throwing {@link TurnSpecError} if that makes the turn
-     * invalid.
+     * invalid. Pass an id (or `{ id, tag }`) to name it in `of`; a `tag` can be
+     * shared by several attacks and names all of them at once.
      *
-     * A rider with no explicit `of` watches every declared attack *including ones
-     * appended after it*, because `of` is resolved when the plan is built rather
-     * than when the rider is added. Pass an explicit `of` to pin a rider to the
-     * attacks it already saw. One attack must exist before a rider with a default
-     * `of` is added, or the build fails `unknown-id`.
+     * Declare attacks before the riders that watch them. A rider added without an
+     * `of` watches the attacks declared *so far*, so appending one after it throws
+     * `attack-after-rider` rather than silently leaving the new attack out. Give
+     * that rider an explicit `of` to pin it to the attacks it already saw.
      */
-    attack(source: Source, id?: string): Turn;
+    attack(source: Source, options?: string | AttackOptions): Turn;
     /**
      * Appends `count` copies of the same attack — the Extra Attack case, which is
-     * most of 5e. Argument order mirrors `roll(count, die)`.
+     * most of 5e. Argument order mirrors `roll(count, die)`. `tag` names every copy
+     * at once in a later `of`.
      *
      * ```ts
      * turn().attacks(4, greatsword).onEveryHit(d6); // fighter 20 + hunter's mark
@@ -50,35 +68,89 @@ export declare class Turn {
      *
      * @throws {RangeError} if `count` is not a positive integer.
      */
-    attacks(count: number, source: Source): Turn;
+    attacks(count: number, source: Source, options?: {
+        tag?: string;
+    }): Turn;
+    private refuseAttackAfterRider;
     /**
      * Appends a rider, throwing {@link TurnSpecError} if that makes the turn
      * invalid. The `onX` methods below are the readable way to call this.
+     *
+     * An omitted `of` is filled in here, not when the plan is built: the attacks
+     * declared so far, plus any attack-shaped `any-miss` / `first-miss` rider
+     * declared so far. Nothing else joins — not `every-hit` riders, not
+     * damage-shaped riders, not a list of several attacks, not `dice-match` beams
+     * (name those explicitly).
      */
     rider(rider: Rider): Turn;
+    /**
+     * Adds what one trigger-verb call describes: its damage as a rider, its grants as
+     * a condition over the same `of`. The gate (`save` / `chance` / `onSave`) applies
+     * to the grants only; the damage lands whatever the save does. With both, `id`
+     * names the rider and the condition takes the default `condition N`.
+     */
+    private addEffect;
     /**
      * Fires once, on the first source that lands, in that source's mode — so a
      * crit on the first landing attack doubles the rider's dice. Sneak Attack.
+     *
+     * Given a {@link Transform} such as `keepBestDamage()` instead of damage, it
+     * adds a once-per-turn substitute: the first watched landing its policy accepts
+     * draws the transformed base payload instead. One call covers every watched
+     * attack; a second over any of the same attacks is `duplicate-substitute`. A
+     * substitute allocates no trigger group. `fireProbability(id)` is P(spent).
+     *
+     * Given a {@link Grant}, the first landing applies it once — a passed save is
+     * final for the turn:
+     *
+     * ```ts
+     * turn([fist, fist, fist]).onFirstHit(advantage().critOnHit().untilEndOfTurn(), { chance: 0.4 });
+     * ```
      */
-    onFirstHit(damage: RiderDamage, options?: RiderOptions): Turn;
+    onFirstHit(effect: Effect | Transform, options?: ConditionOptions): Turn;
     /**
      * Fires once if any source crit, always in crit mode. Divine Smite: nothing is
      * lost by holding it for a crit, so this is "any", not "first".
+     *
+     * Given a {@link Grant}, every crit applies it.
      */
-    onAnyCrit(damage: RiderDamage, options?: RiderOptions): Turn;
+    onAnyCrit(effect: Effect, options?: ConditionOptions): Turn;
     /**
-     * Fires once if any source missed. The reroll gate: a reroll is a fresh attack,
-     * so pass one as the damage. Kensei's Unerring Accuracy, Lucky.
+     * Fires once if any source missed. A reroll is a fresh attack, so pass one as
+     * the damage.
+     *
+     * Its step runs after every declared attack. That is exact when the reroll is
+     * identically distributed to the attacks after the one it replaces; when it is
+     * not, or a later rider reads the order things landed in, use
+     * {@link Turn.onFirstMiss}. A reroll that reads a granted modifier or applies a
+     * condition's grants throws `unsupported-trigger`: use {@link Turn.onFirstMiss}.
      */
     onAnyMiss(damage: RiderDamage, options?: RiderOptions): Turn;
+    /**
+     * Fires once, on the first source that misses, and resolves directly after that
+     * attack — so a reroll lands in turn order, before the attacks that follow it,
+     * and reads the grants in force at that point. The exact model of "when you
+     * miss, you may reroll": Kensei's Unerring Accuracy, Lucky.
+     */
+    onFirstMiss(damage: RiderDamage, options?: RiderOptions): Turn;
     /**
      * Fires once per source that lands, in that hit's mode — so it can fire several
      * times in a turn. Hunter's Mark, Hex, Rage.
+     *
+     * Given a {@link Grant}, every landing applies it, and a `save` or `chance` is
+     * rolled again on each landing until it takes:
+     *
+     * ```ts
+     * turn([sword, sword, sword]).onEveryHit(advantage().untilNextAttack());
+     * turn([axe, axe]).onEveryHit(advantage().untilEndOfTurn(), { save: d20.plus(2).dc(15) });
+     * ```
      */
-    onEveryHit(damage: RiderDamage, options?: RiderOptions): Turn;
+    onEveryHit(effect: Effect, options?: ConditionOptions): Turn;
     /**
      * Damage for the turns where the rider added just before this one did *not*
-     * fire: "flurry of blows if I didn't smite".
+     * fire: "flurry of blows if I didn't smite". After a transform, it fires when
+     * the transform was never spent — under the default policy, when no watched
+     * attack landed.
      *
      * ```ts
      * turn([dagger, dagger])
@@ -87,13 +159,38 @@ export declare class Turn {
      * ```
      *
      * Always binds to the *immediately* preceding rider, so the two are branches of
-     * one decision and can never both land. Note that chaining it therefore
-     * alternates rather than laddering: `a.otherwise(b).otherwise(c)` makes `c`
-     * fire whenever `b` did not, which is exactly when `a` did. For a genuine
-     * three-way priority chain, name the riders and use explicit `not-fired`
-     * triggers against the right one.
+     * one decision and can never both land. Chaining it therefore alternates rather
+     * than laddering: `a.otherwise(b).otherwise(c)` makes `c` fire whenever `b` did
+     * not, which is exactly when `a` did. For a genuine three-way priority chain,
+     * name the riders and use explicit `not-fired` triggers against the right one.
      */
     otherwise(damage: RiderDamage, options?: Omit<RiderOptions, "of">): Turn;
+    /**
+     * Fires once if any of `of`'s named sources' own damage dice matched (showed a
+     * duplicate value) on hit or crit — Chromatic Orb's bounce. Unlike the other
+     * `onX` triggers, `of` is required: "the dice matched" has no coherent meaning
+     * defaulted across every declared attack. Each named source must expose a
+     * dice-match descriptor (an `AttackBuilder`-shaped source does); naming one
+     * that doesn't is a `TurnSpecError("no-dice-descriptor", ...)`.
+     *
+     * Most callers want {@link bounce} instead of calling this directly — it
+     * builds the whole depth-capped chain of attack-shaped riders.
+     */
+    onDiceMatch(of: readonly string[], damage: RiderDamage, options?: Omit<RiderOptions, "of">): Turn;
+    /**
+     * The same turn against a target with armor class `ac`: every attack with an
+     * AC — declared, or carried by a rider (a reroll, a bonus attack) — is rebuilt
+     * through `withCheck`. Saves, attacks with no AC to rebind, and bare PMFs pass
+     * through unchanged, so a mixed attack/save turn still sweeps.
+     *
+     * ```ts
+     * const base = turn([sword, sword]).onFirstHit(roll(3, d6));
+     * [12, 14, 16, 18].map((ac) => base.vsAC(ac).mean());
+     * ```
+     *
+     * @throws {TurnSpecError} `no-rebindable-source` if nothing in the turn has an AC.
+     */
+    vsAC(ac: number): Turn;
     /**
      * The exact joint distribution: mass 1, outcome-labelled. Resolved once and
      * cached.
@@ -125,12 +222,27 @@ export declare class Turn {
      * defaults. These are the names {@link Turn.fireProbability} accepts.
      */
     get riderIds(): readonly string[];
+    /**
+     * Substitute ids in declaration order, including the `substitute 1`, … defaults.
+     * {@link Turn.fireProbability} accepts these too.
+     */
+    get substituteIds(): readonly string[];
+    /**
+     * Condition ids in declaration order, including the `condition 1`, … defaults.
+     * {@link Turn.fireProbability} accepts these too.
+     */
+    get conditionIds(): readonly string[];
     /**
      * P(this rider fired). For an `every-hit` rider it is P(at least one source
-     * hit), since that rider can fire more than once in a turn.
+     * hit), since that rider can fire more than once in a turn. For a substitute it
+     * is P(it was spent). For a condition it is P(its grants were applied at least
+     * once where a later attack roll reads them) — on the fail branch of its save,
+     * not the `onSave` one. Two attacks with "a hit gives the next attack
+     * advantage" give P(attack 1 landed), since nothing reads attack 2's grant.
      *
-     * @throws {TurnSpecError} `unknown-id` if `id` is not a rider — attack ids
-     * included, since attacks always happen and have no firing probability.
+     * @throws {TurnSpecError} `unknown-id` if `id` is not a rider, substitute or
+     * condition — attack ids included, since attacks always happen and have no
+     * firing probability.
      */
     fireProbability(id: string): number;
     private resolve;
@@ -146,4 +258,28 @@ export declare class Turn {
  * ```
  */
 export declare function turn(attacks?: Attack | readonly Attack[], eps?: number): Turn;
+/**
+ * `bounce({ source, max })` — sugar for a depth-capped chain of attack-shaped
+ * `dice-match` riders, so no caller hand-writes the chain by hand: beam 1 is
+ * `source` itself as the turn's only declared attack; beam `i + 1` (for
+ * `i = 1..max`) is `source` again, as a rider fired only when beam `i`'s own
+ * dice matched. Every beam shares `source`'s exact profile (same to-hit, same
+ * damage dice) — the natural reading of "the orb leaps to a new target, same
+ * damage profile, and repeats."
+ *
+ * `max` is required and MUST be a non-negative integer: match probability alone
+ * does not terminate the recursion (Chromatic Orb bounces are not literally
+ * unbounded — DMs cap them by fiat or table size — and something has to).
+ *
+ * Each beam after the first is its own {@link MAX_TRIGGER_GROUPS}-counted trigger
+ * group (`of: [<previous beam's id>]` is a distinct source set every time), so
+ * `max` is effectively capped at the turn's remaining group budget — a chain
+ * asking for more throws `TurnSpecError("too-many-groups", ...)` the same way
+ * any other over-budget turn would, not a silent truncation.
+ */
+export declare function bounce({ source, max }: {
+    source: Source;
+    max: number;
+}): Turn;
+export {};
 //# sourceMappingURL=turn.d.ts.map

package/dist/turn/turn.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"turn.d.ts","sourceRoot":"","sources":["../../src/turn/turn.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAYzC,OAAO,KAAK,EACV,MAAM,EACN,KAAK,EACL,WAAW,EACX,YAAY,EACZ,MAAM,EACN,QAAQ,EACT,MAAM,SAAS,CAAC;AA6CjB;;;;;;;;;;;;;;GAcG;AACH,qBAAa,IAAI;IACf,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAoB;IACpD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAmB;IAC1C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAW;IAChC,OAAO,CAAC,QAAQ,CAAC,CAAsD;IAEvE,OAAO,eAeN;IAED;;;;OAIG;IACH,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,GAAE,MAAY,GAAG,IAAI,CAEnD;IAED;;;;;;;;;OASG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAGxC;IAED;;;;;;;;;OASG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAQ3C;IAED;;;OAGG;IACH,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAExB;IAED;;;OAGG;IACH,UAAU,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,GAAE,YAAiB,GAAG,IAAI,CAEhE;IAED;;;OAGG;IACH,SAAS,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,GAAE,YAAiB,GAAG,IAAI,CAE/D;IAED;;;OAGG;IACH,SAAS,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,GAAE,YAAiB,GAAG,IAAI,CAE/D;IAED;;;OAGG;IACH,UAAU,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,GAAE,YAAiB,GAAG,IAAI,CAEhE;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,CACP,MAAM,EAAE,WAAW,EACnB,OAAO,GAAE,IAAI,CAAC,YAAY,EAAE,IAAI,CAAM,GACrC,IAAI,CAwBN;IAED;;;;;;;OAOG;IACH,IAAI,GAAG,IAAI,GAAG,CAEb;IAED,gCAAgC;IAChC,IAAI,IAAI,MAAM,CAEb;IAED;;;;;;;;OAQG;IACH,OAAO,IAAI,SAAS,CAEnB;IAED;;;OAGG;IACH,IAAI,SAAS,IAAI,SAAS,MAAM,EAAE,CAEjC;IAED;;;OAGG;IACH,IAAI,QAAQ,IAAI,SAAS,MAAM,EAAE,CAEhC;IAED;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAYlC;IAED,OAAO,CAAC,OAAO;CA6HhB;AAED;;;;;;;;;GASG;AACH,wBAAgB,IAAI,CAClB,OAAO,GAAE,MAAM,GAAG,SAAS,MAAM,EAAO,EACxC,GAAG,GAAE,MAAY,GAChB,IAAI,CAKN"}
+{"version":3,"file":"turn.d.ts","sourceRoot":"","sources":["../../src/turn/turn.ts"],"names":[],"mappings":"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"}