@johnmorrisdotca/jirai 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## [0.2.0] - 2026-10-05
+
+- Orthogonal fields: four-neighbour clues, independent hints, proof-backed generation, drawing, saved progress and bilingual controls. Existing square, hexagonal and wraparound modes remain available.
+
 ## 0.1.0 — release candidate
 
 - Square, hexagonal and wraparound fields, seeded and configurable.

package/README.md

@@ -1,12 +1,12 @@
 # Jirai 地雷
 
-**Every number is a clue.** Minesweeper on a square grid, a hexagonal grid, or a board whose opposite edges join. Clear the ground, mark the mines, and finish a field made from a seed.
+**Every number is a clue.** Minesweeper on four-neighbour orthogonal and eight-neighbour square grids, hexagons, or a board whose opposite edges join. Clear the ground, mark the mines, and finish a field made from a seed.
 
 Plain TypeScript rules, no runtime dependencies. The rules work without a browser; the playable board works in any page. A React wrapper and a custom element are separate imports.
 
 ## What it does
 
-- Square, hexagonal and wraparound boards, with width, height and mine count of your own.
+- Orthogonal four-neighbour, square eight-neighbour, hexagonal and wraparound boards, with width, height and mine count of your own.
 - Rectangle, heart, star and hexagon outlines; wide and tall presets. Cut-outs are outside the playable field.
 - A safe first cell, or a clear opening with all its neighbours safe.
 - Verified no-guess fields. A bounded generator throws `GenerationError` if it cannot prove a board; it never substitutes an ordinary field.
@@ -39,9 +39,11 @@ Every move returns a new game and leaves its input untouched. A move which is un
 
 `Settings.shape` may be `rectangle` (the default), `heart`, `star` or `hexagon`. Shaped fields require at least 9 cells on each side and work on square or hexagonal grids; wraparound requires a rectangle. `activeCells(settings)` returns playable row-major cells and `activeCell(settings, cell)` tests membership. Outside cells have clue −2, never contain mines and are excluded from neighbours, solving, drawing and winning. Mine count must be less than the playable cell count.
 
+The dedicated `@johnmorrisdotca/jirai/orthogonal` entry provides `newOrthogonalGame`, `makeOrthogonalBoard`, `orthogonalNeighbours`, `orthogonalHint`, `encodeOrthogonalGame` and `decodeOrthogonalGame`. It applies four-neighbour rules explicitly, so callers do not need to thread a topology string through setup.
+
 The demo uses the family’s original shared stylesheet and header template, with its five table-cloth choices and bilingual Help controls.
 
-Cells are row-major numbers, zero first: `cell = row * width + column`. Hex boards use axial coordinates: neighbours are left, right, above, above-right, below-left and below. A wrap board joins both opposite edges of a square grid.
+Cells are row-major numbers, zero first: `cell = row * width + column`. Orthogonal clues count only the four edge-sharing cells. Square boards count eight neighbours. Hex boards use axial coordinates: neighbours are left, right, above, above-right, below-left and below. A wrap board joins both opposite edges of a square grid.
 
 ```ts
 import { mountJirai } from "@johnmorrisdotca/jirai/play";
@@ -95,7 +97,7 @@ const restored = gameFromProgress(saved); // null for an invalid record
 const seed = dailySeed("2026-10-04", "hex");
 ```
 
-Records are versioned settings and legal moves, not unchecked mine arrays. A seed is only the start of a board's identity: width, height, mine count, grid, no-guess setting, opening policy and first cell matter too. Daily play uses UTC, beginner settings, and the centre opening. The demo's share link includes the first cell after a field has been dealt. Its local save restores the moves, but does not restore elapsed time.
+Ordinary grids keep version 1 progress records. Orthogonal records use version 2 and an explicit `variant: "orthogonal"` marker; `decodeOrthogonalGame` accepts only those records. Existing square, hex and wraparound records keep their format and meaning. A seed is only the start of a board's identity: width, height, mine count, grid, no-guess setting, opening policy and first cell matter too. Daily play uses UTC, beginner settings, and the centre opening. The demo's share link includes the first cell after a field has been dealt. Its local save restores the moves, but does not restore elapsed time.
 
 ## The no-guess promise
 
@@ -121,7 +123,7 @@ The generated standalone page is in `docs/`; the preview serves only on `127.0.0
 
 ## Architecture
 
-Rules: `jirai.types.ts`, `jirai.constants.ts`, `grid.ts`, `random.ts`, `generate.ts`, `flood.ts`, `game.ts`, `deduce.ts`, `enumerate.ts`, `keep.ts`.
+Rules: `jirai.types.ts`, `jirai.constants.ts`, `grid.ts`, `random.ts`, `generate.ts`, `flood.ts`, `game.ts`, `deduce.ts`, `enumerate.ts`, `keep.ts`, `orthogonal.ts`.
 
 Drawing and play: `draw.ts`, `style.ts`, `strings.ts`, `mount.ts`, `worker.ts`, `ui.types.ts`. Framework and tag wrappers are separate entries.
 

package/dist/index.d.ts

@@ -7,5 +7,6 @@ export * from "./game.ts";
 export * from "./deduce.ts";
 export * from "./keep.ts";
 export { seededRandom } from "./random.ts";
-export declare const VERSION = "0.1.0";
+export declare const VERSION = "0.2.0";
 export { SHAPES, activeCell, activeCells } from "./shape.ts";
+export * from "./orthogonal.ts";

package/dist/index.js

@@ -7,5 +7,6 @@ export * from "./game.js";
 export * from "./deduce.js";
 export * from "./keep.js";
 export { seededRandom } from "./random.js";
-export const VERSION = "0.1.0";
+export const VERSION = "0.2.0";
 export { SHAPES, activeCell, activeCells } from "./shape.js";
+export * from "./orthogonal.js";

package/dist/jirai.constants.d.ts

@@ -1,6 +1,7 @@
 import type { Grid, Settings } from "./jirai.types.ts";
 export declare const GRIDS: {
     readonly square: "square";
+    readonly orthogonal: "orthogonal";
     readonly hex: "hex";
     readonly wrap: "wrap";
 };

package/dist/jirai.constants.js

@@ -1,10 +1,11 @@
-export const GRIDS = { square: "square", hex: "hex", wrap: "wrap" };
+export const GRIDS = { square: "square", orthogonal: "orthogonal", hex: "hex", wrap: "wrap" };
 export const STATUSES = { ready: "ready", playing: "playing", won: "won", lost: "lost" };
 export const MARKS = { covered: "covered", flag: "flag", question: "question", open: "open" };
 export const MOVES = { reveal: "reveal", mark: "mark", chord: "chord" };
 /** Hex coordinates are axial: a row is displaced half a cell to the right. */
 export const GRID_SPECS = {
     square: { offsets: [[-1, -1], [0, -1], [1, -1], [-1, 0], [1, 0], [-1, 1], [0, 1], [1, 1]], wrap: false },
+    orthogonal: { offsets: [[0, -1], [-1, 0], [1, 0], [0, 1]], wrap: false },
     hex: { offsets: [[-1, 0], [1, 0], [0, -1], [1, -1], [-1, 1], [0, 1]], wrap: false },
     wrap: { offsets: [[-1, -1], [0, -1], [1, -1], [-1, 0], [1, 0], [-1, 1], [0, 1], [1, 1]], wrap: true },
 };

package/dist/jirai.types.d.ts

@@ -1,5 +1,5 @@
 /** A cell's number is its row-major place on the board, starting at zero. */
-export type Grid = "square" | "hex" | "wrap";
+export type Grid = "square" | "orthogonal" | "hex" | "wrap";
 export type Status = "ready" | "playing" | "won" | "lost";
 export type Mark = "covered" | "flag" | "question" | "open";
 export type Settings = {

package/dist/keep.js

@@ -2,6 +2,9 @@ import { newGame, play } from "./game.js";
 import { validSettings } from "./grid.js";
 /** Keep settings and moves, never an unchecked answer array. Version the deal before changing it. */
 export function gameProgress(game) {
+    if (game.settings.grid === "orthogonal") {
+        return JSON.stringify({ version: 2, variant: "orthogonal", settings: game.settings, moves: game.moves, helped: game.helped });
+    }
     return JSON.stringify({ version: 1, settings: game.settings, moves: game.moves, helped: game.helped });
 }
 /** A saved game is rebuilt under the rules. Malformed or unavailable boards return null. */
@@ -10,7 +13,10 @@ export function gameFromProgress(progress) {
         return null;
     try {
         const data = JSON.parse(progress);
-        if (data.version !== 1 || !validSettings(data.settings) || !Array.isArray(data.moves) || data.moves.length > 20_000)
+        const orthogonalCode = data.version === 2 && data.variant === "orthogonal";
+        if ((!orthogonalCode && data.version !== 1) || !validSettings(data.settings)
+            || orthogonalCode !== (data.settings.grid === "orthogonal")
+            || !Array.isArray(data.moves) || data.moves.length > 20_000)
             return null;
         if (data.helped !== undefined && typeof data.helped !== "boolean")
             return null;
@@ -34,7 +40,8 @@ export function dailySeed(day, grid = "square") {
     if (!/^\d{4}-\d{2}-\d{2}$/.test(day) || new Date(`${day}T00:00:00Z`).toISOString().slice(0, 10) !== day)
         throw new RangeError("Use a real day as YYYY-MM-DD.");
     let hash = 2166136261;
-    for (const letter of `jirai:1:${day}:${grid}`)
+    const version = grid === "orthogonal" ? 2 : 1;
+    for (const letter of `jirai:${version}:${day}:${grid}`)
         hash = Math.imul(hash ^ letter.charCodeAt(0), 16777619) >>> 0;
     return hash;
 }

package/dist/orthogonal.d.ts

@@ -0,0 +1,16 @@
+import type { Board, GenerationOptions, Game, Settings } from "./jirai.types.ts";
+/** Identifies the four-neighbour rules and progress-code format. */
+export declare const ORTHOGONAL_VARIANT: "orthogonal";
+export type OrthogonalSettings = Omit<Settings, "grid">;
+/** Starts a game under four-neighbour rules. */
+export declare function newOrthogonalGame(settings: OrthogonalSettings): Game;
+/** Deals a board whose clues count only up, down, left and right. */
+export declare function makeOrthogonalBoard(settings: OrthogonalSettings, first: number, options?: GenerationOptions): Board;
+/** Returns the adjacent cells under the orthogonal rules. */
+export declare function orthogonalNeighbours(settings: OrthogonalSettings, cell: number): number[];
+/** Gives a clue-only deduction; flags remain notes and cannot influence the result. */
+export declare function orthogonalHint(game: Game): import("./jirai.types.ts").Deduction;
+/** Encodes an orthogonal game with an explicit variant marker and version 2. */
+export declare function encodeOrthogonalGame(game: Game): string;
+/** Restores only version 2 orthogonal progress records. */
+export declare function decodeOrthogonalGame(code: string): Game | null;

package/dist/orthogonal.js

@@ -0,0 +1,39 @@
+import { deduce } from "./deduce.js";
+import { newGame, visibleGame } from "./game.js";
+import { makeBoard } from "./generate.js";
+import { neighbours, validSettings } from "./grid.js";
+import { gameFromProgress, gameProgress } from "./keep.js";
+/** Identifies the four-neighbour rules and progress-code format. */
+export const ORTHOGONAL_VARIANT = "orthogonal";
+/** Starts a game under four-neighbour rules. */
+export function newOrthogonalGame(settings) {
+    return newGame({ ...settings, grid: ORTHOGONAL_VARIANT });
+}
+/** Deals a board whose clues count only up, down, left and right. */
+export function makeOrthogonalBoard(settings, first, options) {
+    return makeBoard({ ...settings, grid: ORTHOGONAL_VARIANT }, first, options);
+}
+/** Returns the adjacent cells under the orthogonal rules. */
+export function orthogonalNeighbours(settings, cell) {
+    const complete = { ...settings, grid: ORTHOGONAL_VARIANT };
+    if (!validSettings(complete))
+        throw new RangeError("Invalid orthogonal settings.");
+    return neighbours(complete, cell);
+}
+/** Gives a clue-only deduction; flags remain notes and cannot influence the result. */
+export function orthogonalHint(game) {
+    if (game.settings.grid !== ORTHOGONAL_VARIANT)
+        throw new RangeError("Expected an orthogonal game.");
+    return deduce(visibleGame(game));
+}
+/** Encodes an orthogonal game with an explicit variant marker and version 2. */
+export function encodeOrthogonalGame(game) {
+    if (game.settings.grid !== ORTHOGONAL_VARIANT)
+        throw new RangeError("Expected an orthogonal game.");
+    return gameProgress(game);
+}
+/** Restores only version 2 orthogonal progress records. */
+export function decodeOrthogonalGame(code) {
+    const game = gameFromProgress(code);
+    return game?.settings.grid === ORTHOGONAL_VARIANT ? game : null;
+}

package/package.json

@@ -1,27 +1,74 @@
 {
   "name": "@johnmorrisdotca/jirai",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Minesweeper on square, hexagonal and wraparound boards: seeded games, a safe opening, verified no-guess boards, explained hints, configurable materials and markers, and a playable board for any page. Zero runtime dependencies.",
   "type": "module",
   "license": "MIT",
   "author": "John Morris",
-  "repository": { "type": "git", "url": "git+https://github.com/johnmorrisdotca/jirai.git" },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/johnmorrisdotca/jirai.git"
+  },
   "homepage": "https://johnmorrisdotca.github.io/jirai/",
-  "bugs": { "url": "https://github.com/johnmorrisdotca/jirai/issues" },
-  "keywords": ["minesweeper", "puzzle", "hexagonal", "no-guess", "typescript", "seeded", "web-component", "itsutsu"],
+  "bugs": {
+    "url": "https://github.com/johnmorrisdotca/jirai/issues"
+  },
+  "keywords": [
+    "minesweeper",
+    "puzzle",
+    "hexagonal",
+    "orthogonal",
+    "no-guess",
+    "typescript",
+    "seeded",
+    "web-component",
+    "itsutsu"
+  ],
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
-    ".": { "types": "./dist/index.d.ts", "default": "./dist/index.js" },
-    "./play": { "types": "./dist/play-entry.d.ts", "default": "./dist/play-entry.js" },
-    "./draw": { "types": "./dist/draw-entry.d.ts", "default": "./dist/draw-entry.js" },
-    "./element": { "types": "./dist/element.d.ts", "default": "./dist/element.js" },
-    "./element/define": { "types": "./dist/element-define.d.ts", "default": "./dist/element-define.js" },
-    "./react": { "types": "./dist/react.d.ts", "default": "./dist/react.js" }
-  },
-  "sideEffects": ["./dist/element-define.js"],
-  "files": ["dist", "src", "README.md", "LICENSE", "CHANGELOG.md"],
-  "engines": { "node": ">=22" },
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./orthogonal": {
+      "types": "./dist/orthogonal.d.ts",
+      "default": "./dist/orthogonal.js"
+    },
+    "./play": {
+      "types": "./dist/play-entry.d.ts",
+      "default": "./dist/play-entry.js"
+    },
+    "./draw": {
+      "types": "./dist/draw-entry.d.ts",
+      "default": "./dist/draw-entry.js"
+    },
+    "./element": {
+      "types": "./dist/element.d.ts",
+      "default": "./dist/element.js"
+    },
+    "./element/define": {
+      "types": "./dist/element-define.d.ts",
+      "default": "./dist/element-define.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "default": "./dist/react.js"
+    }
+  },
+  "sideEffects": [
+    "./dist/element-define.js"
+  ],
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.check.json",
@@ -33,13 +80,26 @@
     "test:package": "pnpm build && node scripts/check-package.mjs",
     "prepublishOnly": "pnpm check && pnpm test:package"
   },
-  "peerDependencies": { "react": ">=18" },
-  "peerDependenciesMeta": { "react": { "optional": true } },
+  "peerDependencies": {
+    "react": ">=18"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
   "devDependencies": {
-    "@eslint/js": "^9.0.0", "eslint": "^9.0.0", "typescript-eslint": "^8.0.0",
-    "typescript": "^5.9.0", "vitest": "^4.0.0", "@playwright/test": "^1.58.0",
-    "@types/react": "^19.0.0", "react": "^19.0.0"
+    "@eslint/js": "^9.0.0",
+    "eslint": "^9.0.0",
+    "typescript-eslint": "^8.0.0",
+    "typescript": "^5.9.0",
+    "vitest": "^4.0.0",
+    "@playwright/test": "^1.58.0",
+    "@types/react": "^19.0.0",
+    "react": "^19.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
   },
-  "publishConfig": { "access": "public" },
   "packageManager": "pnpm@10.11.0"
 }

package/src/deduce.test.ts

@@ -25,8 +25,8 @@ it("enumeration proves only cells forced in every consistent assignment", () =>
   expect(enumerateForced([{ cells: [0], mines: 2, sources: [] }]).contradiction).toBe(true);
 });
 
-it("agrees with an independent exhaustive oracle on square, hex and wrapped 3×3 positions", () => {
-  for (const grid of ["square", "hex", "wrap"] as Grid[]) {
+it("agrees with an independent exhaustive oracle on square, orthogonal, hex and wrapped 3×3 positions", () => {
+  for (const grid of ["square", "orthogonal", "hex", "wrap"] as Grid[]) {
     const settings = { ...DEFAULT_SETTINGS, width: 3, height: 3, mines: 2, grid };
     for (let firstMine = 0; firstMine < 9; firstMine += 1) for (let secondMine = firstMine + 1; secondMine < 9; secondMine += 1) {
       const actual = [firstMine, secondMine];

package/src/game.test.ts

@@ -2,10 +2,12 @@ import { describe, expect, it } from "vitest";
 import { newGame, play, visibleGame } from "./game.ts";
 import { makeBoard, isSolvable, GenerationError } from "./generate.ts";
 import { DEFAULT_SETTINGS, GRIDS, MARKS, MOVES, STATUSES } from "./jirai.constants.ts";
-import { neighbours, neighboursOf, validSettings } from "./grid.ts";
+import { neighbours, neighboursOf, validCell, validSettings } from "./grid.ts";
 import { gameFromProgress, gameProgress, dailySeed } from "./keep.ts";
 import { boardModel } from "./draw.ts";
+import { hintFor } from "./deduce.ts";
 import type { Board, Game, Settings } from "./jirai.types.ts";
+import { decodeOrthogonalGame, encodeOrthogonalGame, makeOrthogonalBoard, newOrthogonalGame, orthogonalHint, orthogonalNeighbours } from "./orthogonal.ts";
 
 function fixedGame(minesAt: number[]): Game {
   const settings: Settings = { ...DEFAULT_SETTINGS, width: 5, height: 5, mines: minesAt.length, noGuess: false, opening: "safe" };
@@ -15,7 +17,7 @@ function fixedGame(minesAt: number[]): Game {
   return { ...newGame(settings), board };
 }
 
-describe("the three boards", () => {
+describe("the grid topologies", () => {
   for (const grid of Object.values(GRIDS)) it(`${grid} has reciprocal, unique neighbours and no self-neighbours`, () => {
     const settings = { ...DEFAULT_SETTINGS, width: 7, height: 5, grid };
     const all = neighboursOf(settings);
@@ -25,11 +27,32 @@ describe("the three boards", () => {
       for (const n of all[cell]!) expect(all[n]).toContain(cell);
     }
   });
-  it("uses six hex neighbours, eight square neighbours, and joins both wrap seams", () => {
+  it("uses four orthogonal neighbours, six hex neighbours, eight square neighbours, and joins both wrap seams", () => {
+    expect(neighbours({ ...DEFAULT_SETTINGS, grid: GRIDS.orthogonal }, 40)).toHaveLength(4);
     expect(neighbours({ ...DEFAULT_SETTINGS, grid: GRIDS.hex }, 40)).toHaveLength(6);
     expect(neighbours(DEFAULT_SETTINGS, 40)).toHaveLength(8);
     expect(neighbours({ ...DEFAULT_SETTINGS, grid: GRIDS.wrap }, 0)).toEqual([1,8,9,10,17,72,73,80]);
   });
+  it("uses only orthogonal clues, preserves playable voids, and verifies a no-guess deal", () => {
+    const settings = { ...DEFAULT_SETTINGS, width: 9, height: 9, mines: 10, grid: GRIDS.orthogonal, seed: 19 };
+    const board = makeBoard(settings, 40);
+    expect(board.clues[40]).toBe(0);
+    for (let cell = 0; cell < 81; cell += 1) {
+      expect(board.clues[cell]).toBe(board.mines[cell] ? -1 : neighbours(settings, cell).filter(next => board.mines[next]).length);
+    }
+    expect(isSolvable(board)).toBe(true);
+    const shaped = { ...settings, shape: "heart" as const };
+    const shapedBoard = makeBoard(shaped, 40);
+    for (let cell = 0; cell < 81; cell += 1) if (!validCell(shaped, cell)) {
+      expect(shapedBoard.mines[cell]).toBe(false);
+      expect(shapedBoard.clues[cell]).toBe(-2);
+      expect(neighbours(shaped, cell)).toEqual([]);
+    }
+    const playing = play(newGame(settings), { kind: MOVES.reveal, cell: 40 });
+    const proof = hintFor(visibleGame(playing));
+    expect(proof.safe.every(cell => !playing.board!.mines[cell])).toBe(true);
+    expect(proof.mines.every(cell => playing.board!.mines[cell])).toBe(true);
+  });
   it("rejects malformed or excessive settings before making a board", () => {
     for (const change of [{ width: 1 }, { width: 61 }, { width: 60, height: 60 }, { mines: 81 }, { seed: NaN }, { grid: "__proto__" }, { mines: 1.5 }, { noGuess: "yes" }]) expect(validSettings({ ...DEFAULT_SETTINGS, ...change })).toBe(false);
   });
@@ -113,8 +136,28 @@ describe("moves", () => {
     expect(gameFromProgress(gameProgress(game))).toEqual(game);
     for (const data of ["garbage", "null", '{"version":2}', JSON.stringify({ version: 1, settings: DEFAULT_SETTINGS, moves: [{ kind: "reveal", cell: -1 }] })]) expect(gameFromProgress(data)).toBeNull();
   });
+  it("keeps orthogonal save records distinct and preserves legacy square codes", () => {
+    const legacy = JSON.stringify({ version: 1, settings: DEFAULT_SETTINGS, moves: [], helped: false });
+    expect(gameFromProgress(legacy)).toEqual(newGame());
+    const orthogonal = newGame({ ...DEFAULT_SETTINGS, grid: GRIDS.orthogonal });
+    const code = gameProgress(orthogonal);
+    expect(JSON.parse(code)).toMatchObject({ version: 2, variant: "orthogonal", settings: { grid: "orthogonal" } });
+    expect(gameFromProgress(code)).toEqual(orthogonal);
+    expect(gameFromProgress(JSON.stringify({ ...JSON.parse(code), variant: "square" }))).toBeNull();
+  });
+  it("exposes focused orthogonal helpers and variant-only progress codes", () => {
+    const settings = { ...DEFAULT_SETTINGS, width: 9, height: 9, mines: 10, seed: 4 };
+    const game = newOrthogonalGame(settings);
+    expect(game.settings.grid).toBe("orthogonal");
+    expect(orthogonalNeighbours(settings, 40)).toHaveLength(4);
+    expect(makeOrthogonalBoard(settings, 40).settings.grid).toBe("orthogonal");
+    expect(orthogonalHint(play(game, { kind: MOVES.reveal, cell: 40 })).contradiction).toBe(false);
+    expect(decodeOrthogonalGame(encodeOrthogonalGame(game))).toEqual(game);
+    expect(decodeOrthogonalGame(gameProgress(newGame()))).toBeNull();
+  });
   it("has stable daily seeds and rejects impossible calendar dates", () => {
     expect(dailySeed("2026-10-04")).toBe(dailySeed("2026-10-04"));
+    expect(dailySeed("2026-10-04", "orthogonal")).not.toBe(dailySeed("2026-10-04"));
     expect(dailySeed("2026-10-04", "hex")).not.toBe(dailySeed("2026-10-04"));
     expect(() => dailySeed("2026-02-30")).toThrow();
   });

package/src/index.ts

@@ -7,6 +7,8 @@ export * from "./game.ts";
 export * from "./deduce.ts";
 export * from "./keep.ts";
 export { seededRandom } from "./random.ts";
-export const VERSION = "0.1.0";
+export const VERSION = "0.2.0";
 
 export { SHAPES, activeCell, activeCells } from "./shape.ts";
+
+export * from "./orthogonal.ts";

package/src/jirai.constants.ts

@@ -1,12 +1,13 @@
 import type { Grid, Settings } from "./jirai.types.ts";
 
-export const GRIDS = { square: "square", hex: "hex", wrap: "wrap" } as const;
+export const GRIDS = { square: "square", orthogonal: "orthogonal", hex: "hex", wrap: "wrap" } as const;
 export const STATUSES = { ready: "ready", playing: "playing", won: "won", lost: "lost" } as const;
 export const MARKS = { covered: "covered", flag: "flag", question: "question", open: "open" } as const;
 export const MOVES = { reveal: "reveal", mark: "mark", chord: "chord" } as const;
 /** Hex coordinates are axial: a row is displaced half a cell to the right. */
 export const GRID_SPECS: Record<Grid, { offsets: readonly (readonly [number, number])[]; wrap: boolean }> = {
   square: { offsets: [[-1,-1],[0,-1],[1,-1],[-1,0],[1,0],[-1,1],[0,1],[1,1]], wrap: false },
+  orthogonal: { offsets: [[0,-1],[-1,0],[1,0],[0,1]], wrap: false },
   hex: { offsets: [[-1,0],[1,0],[0,-1],[1,-1],[-1,1],[0,1]], wrap: false },
   wrap: { offsets: [[-1,-1],[0,-1],[1,-1],[-1,0],[1,0],[-1,1],[0,1],[1,1]], wrap: true },
 };

package/src/jirai.types.ts

@@ -1,5 +1,5 @@
 /** A cell's number is its row-major place on the board, starting at zero. */
-export type Grid = "square" | "hex" | "wrap";
+export type Grid = "square" | "orthogonal" | "hex" | "wrap";
 export type Status = "ready" | "playing" | "won" | "lost";
 export type Mark = "covered" | "flag" | "question" | "open";
 export type Settings = {

package/src/keep.ts

@@ -4,6 +4,9 @@ import type { Game, Move } from "./jirai.types.ts";
 
 /** Keep settings and moves, never an unchecked answer array. Version the deal before changing it. */
 export function gameProgress(game: Game): string {
+  if (game.settings.grid === "orthogonal") {
+    return JSON.stringify({ version: 2, variant: "orthogonal", settings: game.settings, moves: game.moves, helped: game.helped });
+  }
   return JSON.stringify({ version: 1, settings: game.settings, moves: game.moves, helped: game.helped });
 }
 
@@ -12,7 +15,10 @@ export function gameFromProgress(progress: string): Game | null {
   if (progress.length > 1_000_000) return null;
   try {
     const data = JSON.parse(progress);
-    if (data.version !== 1 || !validSettings(data.settings) || !Array.isArray(data.moves) || data.moves.length > 20_000) return null;
+    const orthogonalCode = data.version === 2 && data.variant === "orthogonal";
+    if ((!orthogonalCode && data.version !== 1) || !validSettings(data.settings)
+      || orthogonalCode !== (data.settings.grid === "orthogonal")
+      || !Array.isArray(data.moves) || data.moves.length > 20_000) return null;
     if (data.helped !== undefined && typeof data.helped !== "boolean") return null;
     let game = newGame(data.settings);
     for (const move of data.moves) {
@@ -29,6 +35,7 @@ export function gameFromProgress(progress: string): Game | null {
 export function dailySeed(day: string, grid = "square"): number {
   if (!/^\d{4}-\d{2}-\d{2}$/.test(day) || new Date(`${day}T00:00:00Z`).toISOString().slice(0, 10) !== day) throw new RangeError("Use a real day as YYYY-MM-DD.");
   let hash = 2166136261;
-  for (const letter of `jirai:1:${day}:${grid}`) hash = Math.imul(hash ^ letter.charCodeAt(0), 16777619) >>> 0;
+  const version = grid === "orthogonal" ? 2 : 1;
+  for (const letter of `jirai:${version}:${day}:${grid}`) hash = Math.imul(hash ^ letter.charCodeAt(0), 16777619) >>> 0;
   return hash;
 }

package/src/orthogonal.ts

@@ -0,0 +1,49 @@
+import { deduce } from "./deduce.ts";
+import { newGame, visibleGame } from "./game.ts";
+import { makeBoard } from "./generate.ts";
+import { neighbours, validSettings } from "./grid.ts";
+import { gameFromProgress, gameProgress } from "./keep.ts";
+import type { Board, GenerationOptions, Game, Settings } from "./jirai.types.ts";
+
+/** Identifies the four-neighbour rules and progress-code format. */
+export const ORTHOGONAL_VARIANT = "orthogonal" as const;
+export type OrthogonalSettings = Omit<Settings, "grid">;
+
+/** Starts a game under four-neighbour rules. */
+export function newOrthogonalGame(settings: OrthogonalSettings): Game {
+  return newGame({ ...settings, grid: ORTHOGONAL_VARIANT });
+}
+
+/** Deals a board whose clues count only up, down, left and right. */
+export function makeOrthogonalBoard(
+  settings: OrthogonalSettings,
+  first: number,
+  options?: GenerationOptions,
+): Board {
+  return makeBoard({ ...settings, grid: ORTHOGONAL_VARIANT }, first, options);
+}
+
+/** Returns the adjacent cells under the orthogonal rules. */
+export function orthogonalNeighbours(settings: OrthogonalSettings, cell: number): number[] {
+  const complete = { ...settings, grid: ORTHOGONAL_VARIANT } as Settings;
+  if (!validSettings(complete)) throw new RangeError("Invalid orthogonal settings.");
+  return neighbours(complete, cell);
+}
+
+/** Gives a clue-only deduction; flags remain notes and cannot influence the result. */
+export function orthogonalHint(game: Game) {
+  if (game.settings.grid !== ORTHOGONAL_VARIANT) throw new RangeError("Expected an orthogonal game.");
+  return deduce(visibleGame(game));
+}
+
+/** Encodes an orthogonal game with an explicit variant marker and version 2. */
+export function encodeOrthogonalGame(game: Game): string {
+  if (game.settings.grid !== ORTHOGONAL_VARIANT) throw new RangeError("Expected an orthogonal game.");
+  return gameProgress(game);
+}
+
+/** Restores only version 2 orthogonal progress records. */
+export function decodeOrthogonalGame(code: string): Game | null {
+  const game = gameFromProgress(code);
+  return game?.settings.grid === ORTHOGONAL_VARIANT ? game : null;
+}

package/src/shape.test.ts

@@ -9,7 +9,7 @@ import { gameFromProgress, gameProgress } from "./keep.ts";
 import type { Settings } from "./jirai.types.ts";
 
 describe("shaped minefields", () => {
-  for (const shape of ["heart", "star", "hexagon"] as const) for (const grid of [GRIDS.square, GRIDS.hex]) {
+  for (const shape of ["heart", "star", "hexagon"] as const) for (const grid of [GRIDS.square, GRIDS.orthogonal, GRIDS.hex]) {
     it(`${shape}/${grid} omits cells and retains reciprocal neighbours and proved deals`, () => {
       const settings: Settings = { ...DEFAULT_SETTINGS, width: 17, height: 17, mines: 12, shape, grid };
       for (const outside of [-1, 289, 1.5, NaN]) expect(activeCell(settings, outside)).toBe(false);