jev-recipes 0.4.1 → 0.5.0

package/CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- Add `checkers-move`: supply a structured board, player, and legal moves to receive a move ID in one logical Jev request. Includes American/English checkers instructions, board translation, input checks, and offline tests, bringing the source catalog to 81 recipes. No new runtime dependencies; live speed and playing strength remain unmeasured.
+
 - Add `take-turn` and `choose-action` for narrative turn eligibility and game action recommendations, with optional ordered player history, offline tests, and a gameplay composition guide. The source catalog now contains 80 recipes.
 - Clarify that `.mjs` is a standalone Node quickstart option; existing JavaScript ES module and TypeScript projects can use their normal file types and start commands.
 

package/README.md

@@ -11,7 +11,7 @@
 
 <!-- BEGIN GENERATED: summary -->
 
-80 focused recipes for JavaScript and TypeScript. Route messages, check evidence, and label model responses with a function call.
+81 focused recipes for JavaScript and TypeScript. Route messages, check evidence, and label model responses with a function call.
 
 <!-- END GENERATED: summary -->
 
@@ -19,6 +19,10 @@ Each recipe accepts your data, calls [Jev through TypeSafe's API](https://docs.t
 
 For example, give `route` a support message and descriptions of your teams. It returns a team such as `billing`, or a review outcome when the choice is uncertain.
 
+## Watch Jev play checkers against Jev using the checkers-move recipe
+
+https://github.com/user-attachments/assets/4ac10e7b-b57c-4d73-a2fe-fee90cd1e58d
+
 ## Use a recipe
 
 Requires **Node.js 22.9 or newer**, ES modules, and a **[TypeSafe API key](https://console.typesafe.ai/keys)**. Live calls send the supplied input to TypeSafe and use API quota.
@@ -113,15 +117,16 @@ The TypeSafe SDK handles API calls and typed answers. Recipes add the instructio
 
 ## Find your recipe
 
-| Your task                                      | Start with                                                                                                   |
-| ---------------------------------------------- | ------------------------------------------------------------------------------------------------------------ |
-| Send a request to the right team               | [`route`](https://github.com/agencyenterprise/jev-recipes/blob/main/recipes/route/README.md)                 |
-| Find useful passages                           | [`rerank`](https://github.com/agencyenterprise/jev-recipes/blob/main/recipes/rerank/README.md)               |
-| Check whether the evidence is enough to answer | [`answerability`](https://github.com/agencyenterprise/jev-recipes/blob/main/recipes/answerability/README.md) |
-| Check claims against supplied evidence         | [`verify`](https://github.com/agencyenterprise/jev-recipes/blob/main/recipes/verify/README.md)               |
-| Find missing or ambiguous requirements         | [`clarify`](https://github.com/agencyenterprise/jev-recipes/blob/main/recipes/clarify/README.md)             |
-| Label a response's stance toward a claim       | [`claim-stance`](https://github.com/agencyenterprise/jev-recipes/blob/main/recipes/claim-stance/README.md)   |
-| Choose a move from available game actions      | [`choose-action`](https://github.com/agencyenterprise/jev-recipes/blob/main/recipes/choose-action/README.md) |
+| Your task                                              | Start with                                                                                                   |
+| ------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------ |
+| Send a request to the right team                       | [`route`](https://github.com/agencyenterprise/jev-recipes/blob/main/recipes/route/README.md)                 |
+| Find useful passages                                   | [`rerank`](https://github.com/agencyenterprise/jev-recipes/blob/main/recipes/rerank/README.md)               |
+| Check whether the evidence is enough to answer         | [`answerability`](https://github.com/agencyenterprise/jev-recipes/blob/main/recipes/answerability/README.md) |
+| Check claims against supplied evidence                 | [`verify`](https://github.com/agencyenterprise/jev-recipes/blob/main/recipes/verify/README.md)               |
+| Find missing or ambiguous requirements                 | [`clarify`](https://github.com/agencyenterprise/jev-recipes/blob/main/recipes/clarify/README.md)             |
+| Label a response's stance toward a claim               | [`claim-stance`](https://github.com/agencyenterprise/jev-recipes/blob/main/recipes/claim-stance/README.md)   |
+| Choose a move from available game actions              | [`choose-action`](https://github.com/agencyenterprise/jev-recipes/blob/main/recipes/choose-action/README.md) |
+| Choose a checkers move from your board and legal moves | [`checkers-move`](https://github.com/agencyenterprise/jev-recipes/blob/main/recipes/checkers-move/README.md) |
 
 Search, inspect inputs, and try saved results without a key:
 
@@ -133,7 +138,7 @@ npx jev-recipes demo answerability
 
 [Browse the complete catalog](https://github.com/agencyenterprise/jev-recipes/blob/main/recipes/README.md). Each guide includes an import, input reference, result behavior, limitations, and related recipes.
 
-For games, the [gameplay guide](https://github.com/agencyenterprise/jev-recipes/blob/main/docs/gameplay.md) shows how to combine turn eligibility with action selection using rules, current state, and player history.
+For games, the [gameplay guide](https://github.com/agencyenterprise/jev-recipes/blob/main/docs/gameplay.md) starts with a checkers decision using just the board, player, and legal moves. It also covers general action selection and narrative turn eligibility.
 
 <a id="run-your-own-input-from-the-terminal"></a>
 

package/dist/catalog/generated/details/checkers-move.json

@@ -0,0 +1,128 @@
+{
+  "inputSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "board": {
+        "minItems": 1,
+        "maxItems": 24,
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "square": {
+              "type": "string",
+              "pattern": "^(?:[aceg][1357]|[bdfh][2468])$",
+              "description": "A playable square: a1 is bottom left; files a-h, ranks 1-8."
+            },
+            "player": { "type": "string", "enum": ["red", "black"] },
+            "king": {
+              "description": "True for a king; omitted or false for a man.",
+              "type": "boolean"
+            }
+          },
+          "required": ["square", "player"],
+          "additionalProperties": false
+        },
+        "description": "All remaining pieces. Unlisted squares are empty; red moves toward rank 8, black toward rank 1."
+      },
+      "player": {
+        "type": "string",
+        "enum": ["red", "black"],
+        "description": "The side whose turn it is and whose move should be chosen."
+      },
+      "legalMoves": {
+        "minItems": 1,
+        "maxItems": 50,
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "id": {
+              "type": "string",
+              "description": "Your move ID, returned unchanged when selected. __proto__ is reserved."
+            },
+            "from": {
+              "type": "string",
+              "pattern": "^(?:[aceg][1357]|[bdfh][2468])$",
+              "description": "A playable square: a1 is bottom left; files a-h, ranks 1-8."
+            },
+            "path": {
+              "minItems": 1,
+              "maxItems": 12,
+              "type": "array",
+              "items": {
+                "type": "string",
+                "pattern": "^(?:[aceg][1357]|[bdfh][2468])$",
+                "description": "A playable square: a1 is bottom left; files a-h, ranks 1-8."
+              },
+              "description": "Every landing square in order, excluding from. Include the full jump sequence."
+            },
+            "captures": {
+              "description": "Captured piece squares in jump order. Omit or use [] for an ordinary move.",
+              "maxItems": 12,
+              "type": "array",
+              "items": {
+                "type": "string",
+                "pattern": "^(?:[aceg][1357]|[bdfh][2468])$",
+                "description": "A playable square: a1 is bottom left; files a-h, ranks 1-8."
+              }
+            }
+          },
+          "required": ["id", "from", "path"],
+          "additionalProperties": false
+        },
+        "description": "One to fifty complete legal moves from your game, with unique IDs."
+      },
+      "minConfidence": { "type": "number", "minimum": 0, "maximum": 1 }
+    },
+    "required": ["board", "player", "legalMoves"],
+    "additionalProperties": false
+  },
+  "resultSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "model": { "type": "string" },
+      "usage": {
+        "type": "object",
+        "properties": {
+          "input_tokens": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 },
+          "output_tokens": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 }
+        },
+        "required": ["input_tokens", "output_tokens"],
+        "additionalProperties": false
+      },
+      "status": { "type": "string", "enum": ["ready", "review"] },
+      "verdict": { "type": "string", "enum": ["matched", "none", "ambiguous"] },
+      "selection": { "type": ["string", "null"] },
+      "suggestedSelection": { "type": ["string", "null"] },
+      "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+      "probabilities": {
+        "type": "object",
+        "properties": {
+          "candidates": {
+            "type": "object",
+            "propertyNames": { "type": "string" },
+            "additionalProperties": { "type": "number", "minimum": 0, "maximum": 1 }
+          },
+          "none": { "type": "number", "minimum": 0, "maximum": 1 },
+          "ambiguous": { "type": "number", "minimum": 0, "maximum": 1 }
+        },
+        "required": ["candidates", "none", "ambiguous"],
+        "additionalProperties": false
+      }
+    },
+    "required": [
+      "model",
+      "usage",
+      "status",
+      "verdict",
+      "selection",
+      "suggestedSelection",
+      "confidence",
+      "probabilities"
+    ],
+    "additionalProperties": false
+  }
+}

package/dist/catalog/generated/loaders.js

@@ -13,6 +13,7 @@ export const recipeLoaders = {
     'cancellation-check': () => import('../../recipes/cancellation-check/index.js').then((recipe) => (input, options) => recipe.cancellationCheck(recipe.cancellationCheckInputSchema.parse(input), options)),
     'certainty-match': () => import('../../recipes/certainty-match/index.js').then((recipe) => (input, options) => recipe.certaintyMatch(recipe.certaintyMatchInputSchema.parse(input), options)),
     'change-meaning': () => import('../../recipes/change-meaning/index.js').then((recipe) => (input, options) => recipe.changeMeaning(recipe.changeMeaningInputSchema.parse(input), options)),
+    'checkers-move': () => import('../../recipes/checkers-move/index.js').then((recipe) => (input, options) => recipe.checkersMove(recipe.checkersMoveInputSchema.parse(input), options)),
     'choose-action': () => import('../../recipes/choose-action/index.js').then((recipe) => (input, options) => recipe.chooseAction(recipe.chooseActionInputSchema.parse(input), options)),
     'citation-match': () => import('../../recipes/citation-match/index.js').then((recipe) => (input, options) => recipe.citationMatch(recipe.citationMatchInputSchema.parse(input), options)),
     'citation-needed': () => import('../../recipes/citation-needed/index.js').then((recipe) => (input, options) => recipe.citationNeeded(recipe.citationNeededInputSchema.parse(input), options)),

package/dist/catalog/generated/metadata.js

@@ -251,6 +251,29 @@ export const recipeMetadata = [
             },
         ],
     },
+    {
+        id: 'checkers-move',
+        title: 'Choose a checkers move',
+        description: 'Recommend a supplied legal checkers move from a structured board and player, with built-in American/English checkers instructions.',
+        category: 'workflow',
+        tags: ['checkers', 'draughts', 'gameplay', 'board game', 'legal moves', 'kings', 'captures'],
+        limitations: [
+            'Supports the documented 8x8 American/English variant and orientation. Your game supplies complete legal moves and owns turn, draw, and execution rules.',
+            'Validates format, ownership, and capture references; does not generate moves, prove legality, search future positions, or guarantee optimal play.',
+            'Makes one logical Jev request. Tests and demos are offline; live latency and playing strength have not been measured.',
+        ],
+        useWhen: 'Your checkers game already provides its board, acting player, and legal moves, and you want a move ID without writing decision prompts.',
+        related: [
+            {
+                id: 'choose-action',
+                reason: 'Use choose-action for other games, checkers variants, or custom objectives. It accepts your rules and action descriptions instead of translating a checkers board.',
+            },
+            {
+                id: 'take-turn',
+                reason: 'Use take-turn for narrative turn eligibility. Checkers games should supply the known acting player directly without another model call.',
+            },
+        ],
+    },
     {
         id: 'choose-action',
         title: 'Choose a game action from supplied candidates',
@@ -273,6 +296,10 @@ export const recipeMetadata = [
         ],
         useWhen: 'You need to choose the next game action from a list using the current environment, game rules, and previous player actions.',
         related: [
+            {
+                id: 'checkers-move',
+                reason: 'Use checkers-move for a structured American/English checkers board and legal moves, with built-in rules and move descriptions.',
+            },
             {
                 id: 'take-turn',
                 reason: 'Use take-turn to assess whether the player has an opportunity to act now before selecting an action.',

package/dist/catalog/generated/names.d.ts

@@ -1 +1 @@
-export declare const recipeNames: readonly ["action-scope", "answer-consistency", "answer-coverage", "answer-invalidation", "answer-relevance", "answerability", "argument-fit", "attempted-step", "attribution-match", "audience-fit", "cache-match", "cancellation-check", "certainty-match", "change-meaning", "choose-action", "citation-match", "citation-needed", "claim-stance", "clarify", "confirmation-match", "constraint-strength", "context-role", "correction-target", "document-role", "draft-compare", "evaluation-mention", "evidence-conflict", "evidence-independence", "evidence-novelty", "fact-stability", "failure-kind", "feedback-kind", "field-select", "followup-link", "freshness-needed", "frustration-signal", "handoff", "incident-match", "instruction-conflict", "instruction-fit", "intent-change", "issue-impact", "memory-relation", "memory-scope", "memory-value", "passage-duplicate", "preference-kind", "promise-check", "query-equivalence", "query-specificity", "question-leading", "reference-resolve", "repeated-attempt", "reply-template-match", "requirement-testability", "rerank", "resolution-check", "response-needed", "response-refusal", "result-outcome", "result-usefulness", "retrieval-needed", "route", "source-applicability", "step-complete", "step-progress", "summary-coverage", "take-turn", "task-dependency", "task-duplicate", "ticket-match", "tone-check", "tool-fit", "topic-shift", "troubleshooting-fit", "turn-intent", "uncertainty-expression", "urgency-signal", "verify", "workaround-fit"];
+export declare const recipeNames: readonly ["action-scope", "answer-consistency", "answer-coverage", "answer-invalidation", "answer-relevance", "answerability", "argument-fit", "attempted-step", "attribution-match", "audience-fit", "cache-match", "cancellation-check", "certainty-match", "change-meaning", "checkers-move", "choose-action", "citation-match", "citation-needed", "claim-stance", "clarify", "confirmation-match", "constraint-strength", "context-role", "correction-target", "document-role", "draft-compare", "evaluation-mention", "evidence-conflict", "evidence-independence", "evidence-novelty", "fact-stability", "failure-kind", "feedback-kind", "field-select", "followup-link", "freshness-needed", "frustration-signal", "handoff", "incident-match", "instruction-conflict", "instruction-fit", "intent-change", "issue-impact", "memory-relation", "memory-scope", "memory-value", "passage-duplicate", "preference-kind", "promise-check", "query-equivalence", "query-specificity", "question-leading", "reference-resolve", "repeated-attempt", "reply-template-match", "requirement-testability", "rerank", "resolution-check", "response-needed", "response-refusal", "result-outcome", "result-usefulness", "retrieval-needed", "route", "source-applicability", "step-complete", "step-progress", "summary-coverage", "take-turn", "task-dependency", "task-duplicate", "ticket-match", "tone-check", "tool-fit", "topic-shift", "troubleshooting-fit", "turn-intent", "uncertainty-expression", "urgency-signal", "verify", "workaround-fit"];

package/dist/catalog/generated/names.js

@@ -14,6 +14,7 @@ export const recipeNames = [
     'cancellation-check',
     'certainty-match',
     'change-meaning',
+    'checkers-move',
     'choose-action',
     'citation-match',
     'citation-needed',

package/dist/catalog/schema.d.ts

@@ -14,6 +14,7 @@ export declare const recipeNameSchema: z.ZodEnum<{
     "cancellation-check": "cancellation-check";
     "certainty-match": "certainty-match";
     "change-meaning": "change-meaning";
+    "checkers-move": "checkers-move";
     "choose-action": "choose-action";
     "citation-match": "citation-match";
     "citation-needed": "citation-needed";

package/dist/cli/schema.d.ts

@@ -17,6 +17,7 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "cancellation-check": "cancellation-check";
     "certainty-match": "certainty-match";
     "change-meaning": "change-meaning";
+    "checkers-move": "checkers-move";
     "choose-action": "choose-action";
     "citation-match": "citation-match";
     "citation-needed": "citation-needed";
@@ -101,6 +102,7 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "cancellation-check": "cancellation-check";
     "certainty-match": "certainty-match";
     "change-meaning": "change-meaning";
+    "checkers-move": "checkers-move";
     "choose-action": "choose-action";
     "citation-match": "citation-match";
     "citation-needed": "citation-needed";
@@ -182,6 +184,7 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "cancellation-check": "cancellation-check";
     "certainty-match": "certainty-match";
     "change-meaning": "change-meaning";
+    "checkers-move": "checkers-move";
     "choose-action": "choose-action";
     "citation-match": "citation-match";
     "citation-needed": "citation-needed";

package/dist/recipes/checkers-move/demo.json

@@ -0,0 +1,58 @@
+{
+  "input": {
+    "board": [
+      {
+        "square": "c3",
+        "player": "red"
+      },
+      {
+        "square": "b4",
+        "player": "black"
+      },
+      {
+        "square": "d4",
+        "player": "black"
+      },
+      {
+        "square": "f6",
+        "player": "black",
+        "king": true
+      }
+    ],
+    "player": "red",
+    "legalMoves": [
+      {
+        "id": "capture-left",
+        "from": "c3",
+        "path": ["a5"],
+        "captures": ["b4"]
+      },
+      {
+        "id": "capture-right",
+        "from": "c3",
+        "path": ["e5", "g7"],
+        "captures": ["d4", "f6"]
+      }
+    ]
+  },
+  "response": {
+    "model": "demo-fixture",
+    "usage": {
+      "input_tokens": 0,
+      "output_tokens": 0
+    },
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "candidate_1",
+        "confidence": 0.94,
+        "probabilities": {
+          "candidate_0": 0.02,
+          "candidate_1": 0.94,
+          "none": 0.02,
+          "ambiguous": 0.02
+        }
+      }
+    }
+  }
+}

package/dist/recipes/checkers-move/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { CheckersMoveInput, CheckersMoveResult } from './schema.js';
+export declare function checkersMove(input: CheckersMoveInput, options?: RecipeOptions): Promise<CheckersMoveResult>;
+export { checkersMoveInputSchema, checkersMoveResultSchema } from './schema.js';
+export type { CheckersMoveInput, CheckersMoveResult } from './schema.js';

package/dist/recipes/checkers-move/index.js

@@ -0,0 +1,34 @@
+import { selectCandidate } from '../../src/selection.js';
+import { checkersMoveInputSchema, checkersMoveResultSchema } from './schema.js';
+export async function checkersMove(input, options = {}) {
+    const { board, player, legalMoves, minConfidence = 0.8 } = checkersMoveInputSchema.parse(input);
+    const pieces = new Map(board.map((piece) => [piece.square, piece]));
+    const material = { you: { men: 0, kings: 0 }, opponent: { men: 0, kings: 0 } };
+    const position = board.map((piece) => {
+        const owner = piece.player === player ? 'you' : 'opponent';
+        material[owner][piece.king ? 'kings' : 'men'] += 1;
+        return `${piece.square}: ${owner === 'you' ? 'your' : 'opponent'} ${piece.king ? 'king' : 'man'}`;
+    });
+    const candidates = legalMoves.map((move) => {
+        // References and nonempty paths are checked by the input schema.
+        const piece = pieces.get(move.from);
+        const captures = (move.captures ?? []).map((square) => `opponent ${pieces.get(square).king ? 'king' : 'man'} at ${square}`);
+        const promotes = !piece.king && move.path.at(-1).endsWith(player === 'red' ? '8' : '1');
+        return {
+            id: move.id,
+            text: `Move your ${piece.king ? 'king' : 'man'} from ${move.from} to ${move.path.join(' then ')}. ` +
+                `Captures: ${captures.length ? captures.join(', ') : 'none'}.` +
+                (promotes ? ' Promotes to king and ends the turn.' : ''),
+        };
+    });
+    const decision = await selectCandidate({ player, board: position.join('\n'), material }, candidates, 'Choose the supplied move that best advances winning for player in American/English checkers on an 8x8 board. ' +
+        'Coordinates are fixed: a1 is bottom left, a-h run left to right, ranks 1-8 run bottom to top. Only dark squares are playable. ' +
+        'Red men move and capture toward rank 8; black men toward rank 1. Kings move one diagonal square or jump an adjacent opponent in either direction, not flying kings. ' +
+        "Captures are compulsory; each candidate includes its complete jump sequence. Among capture alternatives, taking the most pieces is not compulsory. Reaching the promotion rank ends a man's turn. " +
+        'The caller supplies the full current board and legal moves for the acting player. Unlisted squares are empty. Compare those candidates without inventing moves or reconstructing game history. ' +
+        'Win by leaving the opponent without pieces or legal moves. Consider immediate wins, material including kings, vulnerability to replies, promotion, and mobility. More captures alone do not establish a better move. ' +
+        'Use the supplied material counts; do not assume a draw history or hidden search results. Future uncertainty alone is not ambiguity, but an unresolved tie or insufficient facts to prefer one move requires ambiguous. ' +
+        'Choose none only if no supplied candidate can be used because the supplied position and candidates conflict. Recommend a move without executing it or claiming optimal play.', minConfidence, options);
+    return checkersMoveResultSchema.parse(decision);
+}
+export { checkersMoveInputSchema, checkersMoveResultSchema } from './schema.js';

package/dist/recipes/checkers-move/schema.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+export declare const checkersMoveInputSchema: z.ZodObject<{
+    board: z.ZodArray<z.ZodObject<{
+        square: z.ZodString;
+        player: z.ZodEnum<{
+            red: "red";
+            black: "black";
+        }>;
+        king: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    player: z.ZodEnum<{
+        red: "red";
+        black: "black";
+    }>;
+    legalMoves: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        from: z.ZodString;
+        path: z.ZodArray<z.ZodString>;
+        captures: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const checkersMoveResultSchema: z.ZodObject<{
+    model: z.ZodString;
+    usage: z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+    }, z.core.$strip>;
+    status: z.ZodEnum<{
+        ready: "ready";
+        review: "review";
+    }>;
+    verdict: z.ZodEnum<{
+        matched: "matched";
+        none: "none";
+        ambiguous: "ambiguous";
+    }>;
+    selection: z.ZodNullable<z.ZodString>;
+    suggestedSelection: z.ZodNullable<z.ZodString>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodObject<{
+        candidates: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        none: z.ZodNumber;
+        ambiguous: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type CheckersMoveInput = z.infer<typeof checkersMoveInputSchema>;
+export type CheckersMoveResult = z.infer<typeof checkersMoveResultSchema>;

package/dist/recipes/checkers-move/schema.js

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, selectionResultSchema } from '../../src/schema.js';
+const player = z.enum(['red', 'black']);
+const square = z
+    .string()
+    .regex(/^(?:[aceg][1357]|[bdfh][2468])$/)
+    .describe('A playable square: a1 is bottom left; files a-h, ranks 1-8.');
+const piece = z.strictObject({
+    square,
+    player,
+    king: z.boolean().optional().describe('True for a king; omitted or false for a man.'),
+});
+const move = z
+    .strictObject({
+    id: nonEmptyText
+        .refine((value) => value !== '__proto__', 'This ID is reserved by result serialization.')
+        .describe('Your move ID, returned unchanged when selected. __proto__ is reserved.'),
+    from: square,
+    path: z
+        .array(square)
+        .min(1)
+        .max(12)
+        .describe('Every landing square in order, excluding from. Include the full jump sequence.'),
+    captures: z
+        .array(square)
+        .max(12)
+        .optional()
+        .describe('Captured piece squares in jump order. Omit or use [] for an ordinary move.'),
+})
+    .refine((value) => new Set(value.captures).size === (value.captures?.length ?? 0), 'A piece cannot be captured twice in one move.')
+    .refine((value) => value.path.length === Math.max(1, value.captures?.length ?? 0), 'Use one landing for an ordinary move, or one landing per captured piece.');
+export const checkersMoveInputSchema = z
+    .strictObject({
+    board: z
+        .array(piece)
+        .min(1)
+        .max(24)
+        .refine((pieces) => new Set(pieces.map((value) => value.square)).size === pieces.length, 'Each board square can hold only one piece.')
+        .refine((pieces) => pieces.filter((value) => value.player === 'red').length <= 12 &&
+        pieces.filter((value) => value.player === 'black').length <= 12, 'Each player can have at most twelve pieces.')
+        .describe('All remaining pieces. Unlisted squares are empty; red moves toward rank 8, black toward rank 1.'),
+    player: player.describe('The side whose turn it is and whose move should be chosen.'),
+    legalMoves: z
+        .array(move)
+        .min(1)
+        .max(50)
+        .refine((moves) => new Set(moves.map((value) => value.id)).size === moves.length, 'Move IDs must be unique.')
+        .describe('One to fifty complete legal moves from your game, with unique IDs.'),
+    minConfidence: probability.optional(),
+})
+    .superRefine((input, context) => {
+    const pieces = new Map(input.board.map((value) => [value.square, value]));
+    input.legalMoves.forEach((value, index) => {
+        if (pieces.get(value.from)?.player !== input.player) {
+            context.addIssue({
+                code: 'custom',
+                path: ['legalMoves', index, 'from'],
+                message: 'The starting square must contain a piece owned by player.',
+            });
+        }
+        value.captures?.forEach((captured, captureIndex) => {
+            const target = pieces.get(captured);
+            if (target === undefined || target.player === input.player) {
+                context.addIssue({
+                    code: 'custom',
+                    path: ['legalMoves', index, 'captures', captureIndex],
+                    message: 'Each captured square must contain an opponent piece.',
+                });
+            }
+        });
+    });
+});
+export const checkersMoveResultSchema = selectionResultSchema;

package/dist/src/index.d.ts

@@ -30,6 +30,8 @@ export { certaintyMatch, certaintyMatchInputSchema, certaintyMatchResultSchema,
 export type { CertaintyMatchInput, CertaintyMatchResult, CertaintyMatchVerdict, } from '../recipes/certainty-match/index.js';
 export { changeMeaning, changeMeaningInputSchema, changeMeaningResultSchema, changeMeaningVerdictSchema, } from '../recipes/change-meaning/index.js';
 export type { ChangeMeaningInput, ChangeMeaningResult, ChangeMeaningVerdict, } from '../recipes/change-meaning/index.js';
+export { checkersMove, checkersMoveInputSchema, checkersMoveResultSchema, } from '../recipes/checkers-move/index.js';
+export type { CheckersMoveInput, CheckersMoveResult } from '../recipes/checkers-move/index.js';
 export { chooseAction, chooseActionInputSchema, chooseActionResultSchema, } from '../recipes/choose-action/index.js';
 export type { ChooseActionInput, ChooseActionResult } from '../recipes/choose-action/index.js';
 export { citationMatch, citationMatchInputSchema, citationMatchResultSchema, } from '../recipes/citation-match/index.js';

package/dist/src/index.js

@@ -15,6 +15,7 @@ export { cacheMatch, cacheMatchInputSchema, cacheMatchResultSchema, cacheMatchVe
 export { cancellationCheck, cancellationCheckInputSchema, cancellationCheckResultSchema, cancellationCheckVerdictSchema, } from '../recipes/cancellation-check/index.js';
 export { certaintyMatch, certaintyMatchInputSchema, certaintyMatchResultSchema, certaintyMatchVerdictSchema, } from '../recipes/certainty-match/index.js';
 export { changeMeaning, changeMeaningInputSchema, changeMeaningResultSchema, changeMeaningVerdictSchema, } from '../recipes/change-meaning/index.js';
+export { checkersMove, checkersMoveInputSchema, checkersMoveResultSchema, } from '../recipes/checkers-move/index.js';
 export { chooseAction, chooseActionInputSchema, chooseActionResultSchema, } from '../recipes/choose-action/index.js';
 export { citationMatch, citationMatchInputSchema, citationMatchResultSchema, } from '../recipes/citation-match/index.js';
 export { citationNeeded, citationNeededInputSchema, citationNeededResultSchema, citationNeededVerdictSchema, } from '../recipes/citation-needed/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jev-recipes",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "Small, composable Jev decisions for retrieval, conversations, and agent workflows.",
   "type": "module",
   "license": "MIT",
@@ -80,6 +80,10 @@
       "types": "./dist/recipes/change-meaning/index.d.ts",
       "import": "./dist/recipes/change-meaning/index.js"
     },
+    "./checkers-move": {
+      "types": "./dist/recipes/checkers-move/index.d.ts",
+      "import": "./dist/recipes/checkers-move/index.js"
+    },
     "./choose-action": {
       "types": "./dist/recipes/choose-action/index.d.ts",
       "import": "./dist/recipes/choose-action/index.js"