Engine

Import from @workspace/bridge/engine.

The engine is a set of 12 modules composed from a BridgeContext. It resolves the mode's CoreConfig once, derives the context flags, and pre-binds mode-dependent arguments on the functions that need them. Everything else is the same stateless function you can import from its module sub-path (@workspace/bridge/auction, @workspace/bridge/hands, …).

A function that depends on the context (it would take a CoreConfig, BridgeContext, TeachingMode, SuitVariant or Locale) is only reachable here: the config resolver, the named configs and the (x, config) primitives are internal, and engine.<module> is their partial application. Build the engine for the mode you hold, even outside React; createBridgeEngine is memoized, so the call is cheap.

const engine = createBridgeEngine(
  createBridgeContext({ teachingMode: "h", locale: "en" })
);
engine.getCtx(); // => { teachingMode: "h", locale: "en" }

Exports

BridgeContext

Both fields are required by the type. At runtime a nullish locale falls back to "en", and getCtx() returns this normalised pair.

Memoization

createBridgeEngine caches one engine per teachingMode|locale key. Engines hold no per-call state, so equal inputs give the same object. Treat every value an engine returns as read-only.

Derived axes

The engine derives the capability flags from the mode's CoreConfig at a single internal point, so engine.ctx cannot drift from the config. Read the flags from the engine built for the mode.

const trumpGoal = createBridgeEngine(
  createBridgeContext({ teachingMode: "show-trump-goal" })
);
trumpGoal.ctx.auctionInput; // => "trump"
trumpGoal.ctx.hasInteractiveAuction; // => false

The derivation produces auctionsEnabled, auctionInput, dummyVisible, contractDisplay, isObservation (auctions === "sequence"), partnerHandDuringAuction, userControlsContract (ContractSource === "user"), hasInteractiveAuction (auctionsEnabled && (auctionInput === "sequence" || userControlsContract)) and honorMetric ("hcp" unless the config sets "tht").

getCtx()

Returns the BridgeContext the engine was built from, normalised to { teachingMode, locale }.

engine.ctx

A flat, read-only object of config-derived flags. No functions, no logic: dispatch on the axes instead of on teachingMode.

engine.ctx.variant; // => "classic"
engine.ctx.auctionInput; // => "contract"
engine.ctx.contractDisplay; // => "full"
engine.ctx.userControlsContract; // => true
engine.ctx.validDenominations; // => ["NT"]
engine.ctx.visibility.partnerHandDuringAuction; // => true

The injected shape is ContextModuleConfig:

engine.hands

Bound to the mode's CoreConfig. Dedicated page: Hands.

engine.auction

Dedicated page: Auction.

engine.notation

Bound to the mode's CoreConfig (variant, valid ranks) and the locale. Dedicated page: Notation.

engine.play

Bound to validDenominations and validRanks. Dedicated page: Play.

engine.player

Dedicated page: Player.

engine.pbn

Dedicated page: PBN.

engine.format

Dedicated page: Format.

engine.schemas

Namespaces over the schemas/* files. Dedicated page: Schemas.

schemas/deal is not exposed through the engine; import it directly.

engine.constants

A subset of Constants: SUITS, RANKS, NO_TRUMP, BID_LEVELS, DENOMINATIONS, SUIT_SYMBOLS, PLAYERS, DECLARER_PLAYER, DEFAULT_DEALER, DEFAULT_VULNERABILITY, DEFAULT_LOCALE, VULNERABILITIES, DEFAULT_SCORING_MODE, SCORING_MODES.

engine.parse

const auction = new AuctionBuilder().fromCompact("N / 1S pass 2S AP").build();
engine.auction.getDeclarer(auction); // => "N"
engine.player.getNextPlayer("N"); // => "E"
engine.parse.parseBid("3NT"); // => "3NT"
engine.schemas.player.playerSchema.parse("N"); // => "N"
engine.constants.SUITS; // => ["S", "H", "D", "C"]

engine.stats