jspsych-tangram 0.0.1

package/src/core/components/board/usePieceState.ts

@@ -0,0 +1,178 @@
+import React from "react";
+import { BaseGameController } from "@/core/engine/state/BaseGameController";
+import type { Poly } from "@/core/domain/types";
+import { boundsOfBlueprint, piecePolysAt } from "@/core/engine/geometry";
+
+/**
+ * Piece data interface used throughout the hook system
+ * 
+ * Represents a tangram piece instance with position and blueprint information.
+ * This is the normalized interface used across all board components.
+ */
+export interface PieceData {
+  /** Unique identifier for this piece instance */
+  id: string;
+  
+  /** ID of the blueprint that defines this piece's shape */
+  blueprintId: string;
+  
+  /** X coordinate of the piece's top-left position in SVG space */
+  x: number;
+  
+  /** Y coordinate of the piece's top-left position in SVG space */
+  y: number;
+  
+  /** ID of the sector containing this piece (undefined if floating) */
+  sectorId?: string;
+}
+
+/**
+ * Return interface for usePieceState hook
+ * 
+ * Provides normalized piece data and computed polygon functions for collision
+ * detection and rendering. All functions are memoized for optimal performance.
+ */
+export interface PieceStateHook {
+  /** Array of all pieces from all sectors plus floating pieces */
+  pieces: PieceData[];
+  
+  /** 
+   * Lookup function to find a piece by its ID
+   * @param id - Piece ID to lookup (null-safe)
+   * @returns PieceData or null if not found
+   */
+  pieceById: (id: string | null) => PieceData | null;
+  
+  /** 
+   * Compute world polygons for all pieces in a sector (live/no cache)
+   * @param sectorId - Target sector ID
+   * @returns Array of world-space polygons
+   */
+  sectorPiecePolysLive: (sectorId: string) => Poly[];
+  
+  /** 
+   * Cached version of sectorPiecePolysLive with signature-based invalidation
+   * @param sectorId - Target sector ID  
+   * @returns Cached array of world-space polygons
+   */
+  getSectorPiecePolysCached: (sectorId: string) => Poly[];
+}
+
+/**
+ * Hook for managing piece data and computed polygon states
+ * 
+ * This hook provides normalized access to piece data from the BaseGameController,
+ * combining pieces from sectors and floating state into a unified interface.
+ * It also provides optimized polygon computation functions for collision detection.
+ * 
+ * ## Key Features
+ * - **Unified piece access**: Combines sector and floating pieces
+ * - **Polygon caching**: Optimized collision detection with signature-based cache
+ * - **Live updates**: Reactively updates when controller state changes
+ * - **Null-safe lookups**: Safe piece retrieval by ID
+ * 
+ * ## Performance
+ * - Pieces array is memoized based on controller.updateCount
+ * - Polygon cache uses sector "signature" (piece positions) for invalidation
+ * - Live polygon computation bypasses cache for real-time operations
+ * 
+ * @param controller - BaseGameController instance managing game state
+ * @returns Hook interface with piece data and polygon functions
+ * 
+ * @example
+ * ```typescript
+ * const pieceState = usePieceState(controller);
+ * const allPieces = pieceState.pieces;
+ * const piece = pieceState.pieceById("piece_123");
+ * const sectorPolygons = pieceState.sectorPiecePolysLive("sector_1");
+ * ```
+ */
+export function usePieceState(controller: BaseGameController): PieceStateHook {
+  // --- pieces ---------------------------------------------------------------
+  const pieces = React.useMemo(() => {
+    const out: PieceData[] = [];
+    for (const s of Object.values(controller.state.sectors)) {
+      for (const p of s.pieces) {
+        out.push({
+          id: p.id,
+          blueprintId: p.blueprintId,
+          x: p.pos.x,
+          y: p.pos.y,
+          sectorId: s.sectorId
+        });
+      }
+    }
+    const floating: any = (controller as any)._floating;
+    if (floating?.pieces) {
+      for (const p of floating.pieces) {
+        out.push({
+          id: p.id,
+          blueprintId: p.blueprintId,
+          x: p.pos.x,
+          y: p.pos.y
+        });
+      }
+    }
+    return out;
+  }, [controller.state.sectors, (controller as any)._floating, controller.updateCount]);
+
+  const pieceById = React.useCallback(
+    (id: string | null) => (id ? pieces.find(p => p.id === id) ?? null : null),
+    [pieces]
+  );
+
+  // --- LIVE sector polys (reads controller.state directly) -----------------
+  const sectorPiecePolysLive = React.useCallback(
+    (sectorId: string): Poly[] => {
+      const out: Poly[] = [];
+      const ss = controller.state.sectors[sectorId];
+      if (!ss) return out;
+      for (const p of ss.pieces) {
+        const bp = controller.getBlueprint(p.blueprintId)!;
+        const bb = boundsOfBlueprint(bp, controller.getPrimitive);
+        out.push(...piecePolysAt(bp, bb, { x: p.pos.x, y: p.pos.y }));
+      }
+      return out;
+    },
+    [controller]
+  );
+
+  // --- OPTIONAL: cached variant keyed by a sector "signature" --------------
+  // Sig = pieceId@x,y;... (order-insensitive)
+  const polyCacheRef = React.useRef(
+    new Map<string, { sig: string; polys: Poly[] }>()
+  );
+
+  const sectorSignature = React.useCallback(
+    (sectorId: string): string => {
+      const ss = controller.state.sectors[sectorId];
+      if (!ss) return "";
+      // stable order by id
+      const parts = ss.pieces
+        .slice()
+        .sort((a, b) => (a.id < b.id ? -1 : 1))
+        .map(p => `${p.id}@${p.pos.x},${p.pos.y}`);
+      return parts.join("|");
+    },
+    [controller.state.sectors]
+  );
+
+  const getSectorPiecePolysCached = React.useCallback(
+    (sectorId: string): Poly[] => {
+      const sig = sectorSignature(sectorId);
+      const hit = polyCacheRef.current.get(sectorId);
+      if (hit && hit.sig === sig) return hit.polys;
+      const polys = sectorPiecePolysLive(sectorId);
+      polyCacheRef.current.set(sectorId, { sig, polys });
+      return polys;
+    },
+    [sectorSignature, sectorPiecePolysLive]
+  );
+
+  return {
+    pieces,
+    pieceById,
+    sectorPiecePolysLive,
+    getSectorPiecePolysCached
+  };
+}

package/src/core/components/board/utils.ts

@@ -0,0 +1,76 @@
+import type { Poly } from "@/core/domain/types";
+
+/**
+ * Board Component Utilities
+ * 
+ * This module provides utility functions used by board interaction hooks.
+ * These functions handle coordinate transformations and geometric operations
+ * needed for blueprint interaction and polygon scaling.
+ */
+
+/**
+ * Convert world coordinates to blueprint local coordinates
+ * 
+ * When a user clicks on a blueprint glyph in the blueprint ring, this function
+ * converts the world click coordinates to local coordinates within the blueprint's
+ * coordinate system. This is needed to maintain the clicked point under the cursor
+ * when spawning and dragging new pieces.
+ * 
+ * @param px - World X coordinate (SVG space)
+ * @param py - World Y coordinate (SVG space)  
+ * @param bpGeom - Blueprint geometry information
+ * @param bpGeom.bx - Blueprint center X in world space
+ * @param bpGeom.by - Blueprint center Y in world space
+ * @param bpGeom.cx - Blueprint local center X
+ * @param bpGeom.cy - Blueprint local center Y
+ * @returns Local coordinates within the blueprint's coordinate system
+ * 
+ * @example
+ * ```typescript
+ * const localPoint = blueprintLocalFromWorld(100, 200, {
+ *   bx: 50, by: 50,    // Blueprint is rendered at (50, 50) in world space
+ *   cx: 25, cy: 25     // Blueprint's local center is at (25, 25)
+ * });
+ * // Result: { x: 75, y: 175 } - point in blueprint's local coordinate system
+ * ```
+ */
+export function blueprintLocalFromWorld(
+  px: number,
+  py: number,
+  bpGeom: { bx: number; by: number; cx: number; cy: number }
+) {
+  return { x: px - bpGeom.bx + bpGeom.cx, y: py - bpGeom.by + bpGeom.cy };
+}
+
+/**
+ * Scale polygons by factor S about the origin (no translation/snapping)
+ * 
+ * This function scales polygon coordinates by a factor S around the origin (0,0).
+ * Used for scaling silhouette masks and other geometric shapes when computing
+ * layouts with different scaling factors. The scaling is uniform (same factor
+ * for both X and Y axes).
+ * 
+ * @param polys - Array of polygons to scale
+ * @param S - Scale factor (1.0 = no change, 0.5 = half size, 2.0 = double size)
+ * @returns New array of scaled polygons (original polygons are not modified)
+ * 
+ * @example
+ * ```typescript
+ * const originalPolys = [[
+ *   { x: 10, y: 10 },
+ *   { x: 20, y: 10 }, 
+ *   { x: 15, y: 20 }
+ * ]];
+ * 
+ * const scaledPolys = scalePolys(originalPolys, 2.0);
+ * // Result: [[
+ * //   { x: 20, y: 20 },
+ * //   { x: 40, y: 20 },
+ * //   { x: 30, y: 40 }
+ * // ]]
+ * ```
+ */
+export function scalePolys(polys: Poly[], S: number): Poly[] {
+  if (!polys || polys.length === 0) return [];
+  return polys.map(poly => poly.map(p => ({ x: S * p.x, y: S * p.y })));
+}

package/src/core/components/index.ts

@@ -0,0 +1,33 @@
+/**
+ * Core Components - Plugin-ready exports
+ * 
+ * This module provides the main reusable components for jsPsych plugins.
+ * All components use dependency injection and have no hardcoded defaults.
+ */
+
+// Core game board component
+export { default as GameBoard, useGameBoard } from './board/GameBoard';
+export type { GameBoardConfig, GameBoardProps } from './board/GameBoard';
+
+// Blueprint ring component for plugin UI
+export { default as BlueprintRing, useBlueprintRing } from './pieces/BlueprintRing';
+export type { BlueprintRingProps } from './pieces/BlueprintRing';
+
+// Legacy Board components (deprecated - use GameBoard instead)
+// export { default as Board } from '../../react/components/Board';
+// export { default as BoardView } from '../../react/components/BoardView';
+
+// Re-export hooks for custom implementations
+export { usePieceState } from './board/usePieceState';
+export { useAnchorGrid } from './board/useAnchorGrid'; 
+export { useDragController } from './board/useDragController';
+export { useClickController } from './board/useClickController';
+
+// Re-export types for plugin development
+export type { 
+  PieceData, 
+  PieceStateHook,
+  AnchorDots,
+  DragControllerHook,
+  ClickControllerHook
+} from './board';

package/src/core/components/pieces/BlueprintRing.tsx

@@ -0,0 +1,238 @@
+/**
+ * BlueprintRing - Reusable blueprint selection interface component
+ * 
+ * This component provides the central blueprint selection interface that displays
+ * available piece blueprints in a circular or semicircular arrangement around
+ * a center badge. It handles both primitive pieces and quickstash macros.
+ * 
+ * ## Key Features
+ * - **Dual Mode Display**: Switches between primitives and quickstash collections
+ * - **Flexible Layout**: Adapts to circle and semicircle layout modes  
+ * - **Interactive Badge**: Center button to toggle between piece collections
+ * - **Responsive Geometry**: Automatically calculates ring radius based on content
+ * - **Event Integration**: Provides structured callbacks for piece selection
+ * 
+ * ## Architecture
+ * - Pure presentation component (no internal state management)
+ * - Receives all data and callbacks via props (dependency injection)
+ * - Computes ring geometry based on layout constraints
+ * - Renders SVG blueprint glyphs with proper scaling and positioning
+ * 
+ * ## Usage
+ * Typically used within GameBoard or plugin components:
+ * ```typescript
+ * <BlueprintRing
+ *   primitives={primitiveBlueprints}
+ *   quickstash={macroBlueprints}
+ *   currentView="primitives"
+ *   layout={computedLayout}
+ *   onBlueprintPointerDown={handleBlueprintSelection}
+ *   onCenterBadgePointerDown={handleViewToggle}
+ * />
+ * ```
+ * 
+ * @see {@link GameBoard} Primary container that uses this component
+ * @see {@link useBlueprintRing} Hook for managing blueprint ring state
+ * @since Phase 3.3 - Extracted from monolithic Board component  
+ * @author Claude Code Assistant
+ */
+
+import React from "react";
+import type { Blueprint, TanKind, PrimitiveBlueprint } from "@/core/domain/types";
+import type { CircleLayout } from "@/core/domain/layout";
+import { boundsOfBlueprint } from "@/core/engine/geometry";
+import { CONFIG } from "@/core/config/config";
+
+function pathD(poly: any[]) {
+  return `M ${poly.map((pt: any) => `${pt.x} ${pt.y}`).join(" L ")} Z`;
+}
+
+/**
+ * Props interface for BlueprintRing component
+ * 
+ * This interface defines all the data and callbacks needed to render
+ * the blueprint selection interface. All props use dependency injection.
+ */
+export interface BlueprintRingProps {
+  /** Array of primitive tangram piece blueprints */
+  primitives: PrimitiveBlueprint[];
+  
+  /** Array of quickstash/macro piece blueprints */
+  quickstash: Blueprint[];
+  
+  /** 
+   * Current view mode for blueprint ring
+   * - "primitives": Show primitive tangram pieces
+   * - "quickstash": Show macro/composite pieces
+   */
+  currentView: "primitives" | "quickstash";
+  
+  /** Computed circle layout containing geometry information */
+  layout: CircleLayout;
+  
+  /** Radius of the center toggle badge in pixels */
+  badgeR: number;
+  
+  /** Center position of the toggle badge */
+  badgeCenter: { x: number; y: number };
+  
+  /** Maximum number of quickstash slots to display */
+  maxQuickstashSlots: number;
+  
+  /** ID of currently dragging piece (null if none) - used for interaction state */
+  draggingId: string | null;
+  
+  /** 
+   * Callback fired when user starts interacting with a blueprint
+   * @param e - Pointer event from the interaction
+   * @param bp - Blueprint that was selected  
+   * @param bpGeom - Geometry information for the selected blueprint
+   */
+  onBlueprintPointerDown: (
+    e: React.PointerEvent,
+    bp: Blueprint,
+    bpGeom: { bx: number; by: number; cx: number; cy: number }
+  ) => void;
+  
+  /** 
+   * Callback fired when user clicks the center badge to toggle views
+   * @param e - Pointer event from the badge click
+   */
+  onCenterBadgePointerDown: (e: React.PointerEvent) => void;
+  
+  /** 
+   * Helper function to lookup primitive blueprints by kind
+   * Used for rendering composite pieces that reference primitives
+   */
+  getPrimitive: (kind: TanKind | string) => PrimitiveBlueprint | undefined;
+}
+
+export default function BlueprintRing(props: BlueprintRingProps) {
+  const {
+    primitives,
+    quickstash,
+    currentView,
+    layout,
+    badgeR,
+    badgeCenter,
+    maxQuickstashSlots,
+    draggingId,
+    onBlueprintPointerDown,
+    onCenterBadgePointerDown,
+    getPrimitive
+  } = props;
+  
+  // Determine which blueprints to show
+  const blueprints: Blueprint[] = currentView === "primitives" ? primitives : quickstash;
+  
+  // Calculate ring geometry
+  const QS_SLOTS = maxQuickstashSlots;
+  const PRIM_SLOTS = primitives.length;
+  const slotsForView = currentView === "primitives" ? Math.max(1, PRIM_SLOTS) : Math.max(1, QS_SLOTS);
+  const sweep = layout.mode === "circle" ? Math.PI * 2 : Math.PI;
+  const delta = sweep / slotsForView;
+  
+  const start = layout.mode === "circle" ? -Math.PI / 2 : Math.PI;
+  const blueprintTheta = (i: number) => start + (i + 0.5) * delta;
+  
+  // Chord requirement calculation
+  const anchorsDiameterToPx = (anchorsDiag: number, gridPx: number = CONFIG.layout.grid.stepPx) =>
+    anchorsDiag * Math.SQRT2 * gridPx;
+  const reqAnchors = currentView === "primitives"
+    ? CONFIG.layout.constraints.primitiveDiamAnchors
+    : CONFIG.layout.constraints.quickstashDiamAnchors;
+  const D_slot = anchorsDiameterToPx(reqAnchors);
+  const R_needed = D_slot / (2 * Math.max(1e-9, Math.sin(delta / 2)));
+  
+  // Minimum radius to avoid overlapping with badge
+  // Badge takes up: badgeR + margin, plus we need half the slot diameter for clearance
+  const R_min = badgeR + CONFIG.size.centerBadge.marginPx + D_slot / 2;
+  const ringMax = layout.innerR - (badgeR + CONFIG.size.centerBadge.marginPx);
+  
+  // Clamp to [R_min, ringMax]
+  const blueprintRingR = Math.min(Math.max(R_needed, R_min), ringMax);
+  
+  // Blueprint glyph renderer
+  const renderBlueprintGlyph = (bp: Blueprint, bx: number, by: number) => {
+    const bb = boundsOfBlueprint(bp, (k: string) => getPrimitive(k as TanKind)!);
+    const cx = bb.min.x + bb.width / 2;
+    const cy = bb.min.y + bb.height / 2;
+    const selected = false; // Future enhancement: add selection highlighting
+    
+    return (
+      <g
+        key={bp.id}
+        transform={`translate(${bx}, ${by}) scale(1) translate(${-cx}, ${-cy})`}
+      >
+        {("shape" in bp ? bp.shape : []).map((poly, idx) => (
+          <path
+            key={idx}
+            d={pathD(poly)}
+            fill={CONFIG.color.blueprint.fill}
+            opacity={CONFIG.opacity.blueprint}
+            stroke={selected ? CONFIG.color.blueprint.selectedStroke : "none"}
+            strokeWidth={selected ? 2 : 0}
+            pointerEvents="visiblePainted"
+            style={{ cursor: "pointer" }}
+            onPointerDown={(e) => onBlueprintPointerDown(e as any, bp, { bx, by, cx, cy })}
+          />
+        ))}
+      </g>
+    );
+  };
+  
+  return (
+    <g className="blueprint-ring">
+      {/* Center badge */}
+      <g 
+        transform={`translate(${badgeCenter.x}, ${badgeCenter.y})`} 
+        style={{ cursor: draggingId ? "default" : "pointer" }} 
+        onPointerDown={onCenterBadgePointerDown}
+      >
+        <circle r={badgeR} fill={CONFIG.color.blueprint.badgeFill} />
+        <text 
+          textAnchor="middle" 
+          dominantBaseline="middle" 
+          fontSize={CONFIG.size.badgeFontPx} 
+          fill={CONFIG.color.blueprint.labelFill} 
+          pointerEvents="none"
+        >
+          {currentView}
+        </text>
+      </g>
+
+      {/* Blueprint glyphs in ring formation */}
+      {blueprints.map((bp: Blueprint, i: number) => {
+        const theta = blueprintTheta(i);
+        const bx = layout.cx + blueprintRingR * Math.cos(theta);
+        const by = layout.cy + blueprintRingR * Math.sin(theta);
+        return renderBlueprintGlyph(bp, bx, by);
+      })}
+    </g>
+  );
+}
+
+/**
+ * Hook for managing blueprint ring state
+ * Useful for components that need more control over blueprint ring behavior
+ */
+export function useBlueprintRing(
+  primitives: PrimitiveBlueprint[], 
+  quickstash: Blueprint[], 
+  initialView: "primitives" | "quickstash" = "quickstash"
+) {
+  const [currentView, setCurrentView] = React.useState<"primitives" | "quickstash">(initialView);
+  
+  const switchView = React.useCallback(() => {
+    setCurrentView(prev => prev === "primitives" ? "quickstash" : "primitives");
+  }, []);
+  
+  const blueprints = currentView === "primitives" ? primitives : quickstash;
+  
+  return {
+    currentView,
+    blueprints,
+    switchView,
+    setCurrentView
+  };
+}

package/src/core/config/config.ts

@@ -0,0 +1,85 @@
+// src/core/config/config.ts
+export type Config = {
+  color: {
+    bands: {
+      silhouette: { fillEven: string; fillOdd: string; stroke: string };
+      workspace:  { fillEven: string; fillOdd: string; stroke: string };
+    };
+    completion: { fill: string; stroke: string };
+    silhouetteMask: string;
+    anchors: { invalid: string; valid:   string };
+    piece: { draggingFill: string; validFill: string; invalidFill: string; invalidStroke: string; selectedStroke: string; allGreenStroke: string; borderStroke: string };
+    ui: { light: string; dark: string };
+    blueprint: { fill: string; selectedStroke: string; badgeFill: string; labelFill: string };
+  };
+  opacity: {
+    blueprint: number;
+    silhouetteMask: number;
+    anchors: { invalid: number; valid: number };
+    piece: { invalid: number; dragging: number; locked: number; normal: number };
+  };
+  size: {
+    stroke: { bandPx: number; pieceSelectedPx: number; allGreenStrokePx: number; pieceBorderPx: number };
+    anchorRadiusPx: { valid: number; invalid: number };
+    badgeFontPx: number;
+    centerBadge: { fractionOfOuterR: number; minPx: number; marginPx: number };
+  };
+  layout: {
+    grid: { stepPx: number; unitPx: number };
+    paddingPx: number;
+    /** renamed from capacity → constraints */
+    constraints: {
+      workspaceDiamAnchors: number;
+      quickstashDiamAnchors: number;
+      primitiveDiamAnchors: number;
+    };
+    defaults: { maxQuickstashSlots: number };
+  };
+  game: {
+    snapRadiusPx: number;
+    showBorders: boolean;
+    hideTouchingBorders: boolean;
+  };
+};
+
+export const CONFIG: Config = {
+  color: {
+    bands: {
+      silhouette: { fillEven: "#eef2ff", fillOdd: "#f6f7fb", stroke: "#c7d2fe" },
+      workspace:  { fillEven: "#f3f4f6", fillOdd: "#f9fafb", stroke: "#e5e7eb" }
+    },
+    completion: { fill: "#dcfce7", stroke: "#86efac" },
+    silhouetteMask: "#94a3b8",
+    anchors: { invalid: "#7dd3fc", valid:   "#475569" },
+    piece: { draggingFill: "#1d4ed8", validFill: "#60a5fa", invalidFill: "#ef4444", invalidStroke: "#dc2626", selectedStroke: "#111827", allGreenStroke: "#86efac", borderStroke: "#374151" },
+    ui: { light: "#60a5fa", dark: "#1d4ed8" },
+    blueprint: { fill: "#374151", selectedStroke: "#111827", badgeFill: "#eef2ff", labelFill: "#374151" }
+  },
+  opacity: {
+    blueprint: 0.95,
+    silhouetteMask: 0.45,
+    anchors: { valid: 0.80, invalid: 0.50 },
+    piece: { invalid: 0.35, dragging: 0.60, locked: 0.70, normal: 0.95 },
+  },
+  size: {
+    stroke: { bandPx: 1, pieceSelectedPx: 1.5, allGreenStrokePx: 6, pieceBorderPx: 1 },
+    anchorRadiusPx: { valid: 1.0, invalid: 1.0 },
+    badgeFontPx: 12,
+    centerBadge: { fractionOfOuterR: 0.15, minPx: 20, marginPx: 4 }
+  },
+  layout: {
+    grid: { stepPx: 20, unitPx: 40 },
+    paddingPx: 1,
+    constraints: {
+      workspaceDiamAnchors: 10,  // num anchors req'd to be on diagonal
+      quickstashDiamAnchors: 7,  // num anchors req'd to be in single quickstash slot
+      primitiveDiamAnchors: 5,
+    },
+    defaults: { maxQuickstashSlots: 1 }
+  },
+  game: {
+    snapRadiusPx: 15,
+    showBorders: true,
+    hideTouchingBorders: true
+  }
+};

package/src/core/domain/blueprints.ts

@@ -0,0 +1,25 @@
+import type {
+  Blueprint, PrimitiveBlueprint, CompositeBlueprint, TanKind
+} from "./types";
+
+export function isComposite(bp: Blueprint): bp is CompositeBlueprint {
+  return (bp as CompositeBlueprint).parts !== undefined;
+}
+export function isPrimitive(bp: Blueprint): bp is PrimitiveBlueprint {
+  return !isComposite(bp);
+}
+
+export class BlueprintRegistry {
+  private byId = new Map<string, Blueprint>();
+  private primitivesByKind = new Map<TanKind, PrimitiveBlueprint>();
+
+  registerAll(bps: Blueprint[]) {
+    for (const bp of bps) this.register(bp);
+  }
+  register(bp: Blueprint) {
+    this.byId.set(bp.id, bp);
+    if (isPrimitive(bp)) this.primitivesByKind.set(bp.kind, bp);
+  }
+  get(id: string) { return this.byId.get(id); }
+  getPrimitive(kind: TanKind | string) { return this.primitivesByKind.get(kind as TanKind); }
+}