/* ---------------------------------------------------------------------------
   拆字课 · Radical Forge — HANDS-ON (v2)            prom/css/drill-forge2.css
   Benchmark: Little Alchemy / Infinite Craft for the fusion, Okami for the
   Floral Finisher. Two objects: a tray of stone radicals, and a carving frame
   drawn in the character's own geometry. A third — a held chisel that filled a
   groove before the seal would arm — is gone (Lau, 2026-08-08): it graded
   nothing and was identical every round.

   Colour: ink + cream stock + ONE accent (the shell's aged bronze), plus the
   semantic pair. Stones are told apart by their HANZI, never by hue.

   TYPE — exactly four steps, and they are obviously different (round-4 judging
   measured FIVE here, with a 36px display two pixels off a 34px stone glyph,
   which reads as sloppiness rather than hierarchy):
     --f2-glyph   the display step. EVERY hanzi the player handles as an object
                  — a stone on the tray, a part seated in the frame, the sealed
                  character, the character on the verdict card — is this one
                  size, because they are all literally the same object at
                  different moments. Nothing else in the drill uses it.
     --dk-read    20px. Every sentence, every label written in Chinese, the
                  stones' 笔画 counts, the live cut tally, the shell chips.
     --dk-label   16px. Latin object names, button faces, the legend.
     --dk-caption 14px. Pinyin and glosses ONLY.
   If something does not fit, the words get shorter. Never the type.

   ROUND-6 CORRECTION. The judges counted SIX sizes here, not four:
   [56, 22, 20, 16, 14, 13]. The two extras were both the graffiti — a 13px
   default with one 22px scratch — which the earlier census never saw because
   it skips [aria-hidden] subtrees and the graffiti is aria-hidden. That skip is
   a probe convenience, not a rule: the pixels are on the screen and a reader's
   eye counts them. Decorative etching moved down to the caption step, so four
   steps, measured with the graffiti counted in — see prom/dev/fg6-type.mjs.

   ROUND-8 CORRECTION, and it settles the same argument by removing its subject.
   Round 6 made the graffiti quiet; round 7 measured it and it was still 14px
   HANZI, under the 20px floor, at 3.68:1 and 3.70:1, in both themes, at rest
   and played. It is line work now — no glyph, no size, no ratio — so the
   caption step belongs to pinyin and glosses again and the stage carries three
   fewer text runs. Full working at .f2-graffiti.
   --------------------------------------------------------------------------- */

.minigame.forge2 {
  /* THE DRILL'S ONE ACCENT IS HER SHELL, and it is a brown, not a gold. This
     used to be re-pointed at #b8860b — which is the gold family, i.e. the
     drill declared the live token as its decorative hue and then used a two-
     steps-darker version of it (#6d4f06, byte-identical to --dk-gold-deep) to
     tint the stroke counts on the reveal card. A colour census reads that as
     gold doing decorative work, and it is right to: "gold = the thing to look
     at now" cannot also mean "this run of text is a number". The counts are
     ink now (see .f2-vn), so nothing in this file paints the gold family
     except the four places that earn it. */
  --dk-accent: #8a6a3a;            /* the chisel's handle, the shell's rim */
  --f2-stone: #d5cec3;             /* the tray's grey river stone */
  --f2-stone-2: #b3a99c;
  --f2-shell: #4a3a24;
  --f2-shell-2: #382b1a;
  /* the display step. Sized so a stone on a phone still holds it: at 390 the
     tray is three across (~110px a stone) and this lands at 32px. */
  --f2-glyph: clamp(32px, 4.4vw, 56px);
  --f2-frame: min(192px, 46vw);
}
/* ---------------------------------------------------------- header clearance
   prom.css absolutely-positions `.minigame > .mg-head` at top:18px while every
   other child sits in the flow underneath it, so a drill has to guess a
   padding-top big enough to clear a box whose height it does not own — and gets
   it wrong the moment the plaque wraps to two lines or the light theme makes it
   taller. Same defect, same fix the rush and haggle rebuilds already landed:
   put the plaque back in the flow, where it cannot cover anything at any width
   in either theme however tall it grows. */
/* THE BENCH IS A WORK SURFACE, SO NOTHING ON IT MAY BE SELECTED. Every hand in
   this drill is a press-and-drag, and a press that misses its grab — on the
   walkthrough's dim, on the gap between two stones, on the structure label —
   sweeps a blue native text selection across the tray and the frame instead.
   Measured during the round-9 walkthrough pass: a drag started on a dimmed
   stone left 女三画心四画力二画…左右结构 highlighted behind the coach's card, on
   top of a board the player is being taught to read. Same finding and same fix
   as 成语课's exam sheet (drill-chengyu2.css): a player holding a chisel may
   not be able to highlight the shell. */
.minigame.forge2, .minigame.forge2 * { -webkit-user-select: none; user-select: none; }
.minigame.forge2 { justify-content: flex-start; padding-top: 8px; gap: 8px; }
.minigame.forge2 > .mg-head { position: static; transform: none; }
.minigame.forge2 .mg-head { flex-wrap: wrap; row-gap: 3px; }
.minigame.forge2 .mg-soundhint { display: flex; justify-content: center; font-size: var(--dk-label); }
/* THE ORDINAL IS NOT THE SCORE, AND IT HAS TO STOP LOOKING LIKE ONE.
   Round-10 blind judging: four zeroes in four corners in four styles, and the
   judge could not say which was the score. Two of them stood 40px apart in this
   header and both were over five — 「第 1/5 块」 and the goal chip's
   「刻成 0/5」. The markup dropped this one's denominator (see forge2.js); this
   is the other half, the hierarchy. It cannot be done with SIZE — the hanzi
   floor is 20px and 第/块 are hanzi — so it is done with colour and weight, which
   is the distinction that was missing anyway: the goal chip's count stays paper
   white, and the ordinal goes the same haze as the words around it. One bright
   number in the header, and it is the one counting to the pass bar.
   `inherit` rather than a token, so the light theme's own .mg-score colour
   carries it too — light paints .mg-score b crimson, which is the loudest thing
   in the header for the least important fact on it. */
.forge2 .mg-score #f2Blocks b { color: inherit; font-weight: 800; }

/* -------------------------------------------------------- the practice block
   While the coach is walking the player through, the bench carries a SCRAP
   block instead of one of her five (see enterPractice in forge2.js). Two things
   say so: the head swaps 第 n/5 块 for this tag, and the frame is drawn as a
   dashed offcut rather than a cut ruled into her shell. Both are quiet — the
   coach's card is the thing to read — but neither is guessable from nothing,
   and "does this one count" is the question the old walkthrough answered wrong.
   The tag is a NOTICE, so it carries its English inline at the label step. */
.forge2 .f2-practice {
  display: inline-flex; align-items: baseline; gap: 0.34em;
  padding: 0.02em 0.55em; border-radius: 999px;
  border: 1px dashed color-mix(in srgb, currentColor 52%, transparent);
  font-size: var(--dk-label); line-height: 1.5;
}
.forge2 .f2-practice b { font-size: var(--dk-read); }
.forge2 .f2-practice[hidden] { display: none; }
.forge2.is-practice .f2-frame:not(.sealed) {
  border-style: dashed;
  background-color: rgba(231, 215, 174, 0.06);
}


.forge2 .f2-court {
  display: flex; flex-direction: column; gap: 8px;
  width: min(1040px, 96vw); margin: 0 auto; padding: 2px 0 4px;
}

/* -------------------------------------------------------------- the quiz */
/* HER SPOKEN LINES MOVED TO THE KIT'S OWN BUBBLE (Lau, 2026-08-08): stageHTML's
   host: "axia" now puts her painted card on stage with #mgBubble beside it —
   the same crew.bubble() seam cloze2's Ace and clinic2's Nak use — instead of
   this drill inventing its own nameplate/line/English-line stack for a host
   who had no art of her own. What stays here is BOARD STATE, not speech: the
   sentence with the hole in it, persistent for the whole round regardless of
   what she's currently saying, plus its own de-blurring English gloss. */
.forge2 .f2-tell {
  border-radius: 14px; padding: 9px 16px 8px;
  border: 3px solid var(--dk-ink); box-shadow: var(--dk-drop);
}
/* the prompt: one Chinese sentence with a hole in it. The hole is a 田字格,
   the same object the carving frame is, so the sentence points at the bench. */
.forge2 .f2-quiz {
  margin: 0; color: var(--paper, #f2efe9);
  max-width: min(44ch, 100%); line-height: 1.6; letter-spacing: 0.02em;
}
/* THE HOLE IS THE QUESTION AND IT WAS THE SMALLEST THING IN ITS OWN SENTENCE.
   Round-10 judging: "It's the right idea but it's tiny — smaller than the text
   around it — and it's a long way from the circles I'd use to fill it." At 1.2em
   with a 2.5px dash it measured under the hanzi beside it, so the one warm mark
   in the whole text panel was quieter than the words it interrupts.
   1.42em with a heavier dash and a soft gold bloom: bigger than the characters
   around it, which is what a hole in a line of type has to be to read as a hole
   rather than as punctuation. It is still a 田字格 — the same object the carving
   frame is — so the sentence points at the bench. */
.forge2 .f2-gap {
  display: inline-block; width: 1.42em; height: 1.42em; vertical-align: -0.34em;
  margin: 0 0.14em; border: 3px dashed var(--dk-gold); border-radius: 4px;
  background: rgba(255, 200, 74, 0.14);
  box-shadow: 0 0 14px rgba(255, 200, 74, 0.26);
  text-align: center; line-height: 1.3;
}
.forge2 .f2-gap.on {
  border-style: solid; color: var(--dk-gold);
  background: rgba(255, 200, 74, 0.2);
  animation: f2Fill 0.5s cubic-bezier(.2,1,.3,1);
}
@keyframes f2Fill { 0% { transform: scale(2.1); opacity: 0; } 60% { transform: scale(0.94); } }
/* the de-blur gloss: absent for the first ~3.5s of a round, so the round is set
   in Chinese and the English is the cushion, never the prompt */
.forge2 .f2-en {
  margin: 3px 0 0; color: var(--haze, #a49fae); max-width: min(52ch, 100%);
  opacity: 0; transition: opacity 0.6s ease-out;
}
.forge2 .f2-en.in { opacity: 1; }

/* ------------------------------------------------------------------ body */
.forge2 .f2-body { display: grid; grid-template-columns: minmax(0, 0.92fr) minmax(0, 1fr); gap: 14px; align-items: start; }

/* ----------------------------------------------------------- her shell */
.forge2 .f2-shell {
  position: relative;
  /* a plastron is not a brown blob: it is scutes, and the seams between them */
  background-image:
    linear-gradient(90deg, transparent 31.2%, rgba(24,12,4,0.42) 31.7%, rgba(24,12,4,0.42) 32.5%, transparent 33%),
    linear-gradient(90deg, transparent 67.2%, rgba(24,12,4,0.42) 67.7%, rgba(24,12,4,0.42) 68.5%, transparent 69%),
    linear-gradient(180deg, transparent 23.2%, rgba(24,12,4,0.38) 23.7%, rgba(24,12,4,0.38) 24.5%, transparent 25%),
    linear-gradient(180deg, transparent 76.2%, rgba(24,12,4,0.38) 76.7%, rgba(24,12,4,0.38) 77.5%, transparent 78%),
    radial-gradient(120% 100% at 50% 0%, #5c4930, var(--f2-shell) 55%, var(--f2-shell-2));
  border: 3.5px solid var(--dk-ink);
  border-radius: 40% 40% 36% 36% / 30% 30% 44% 44%;
  box-shadow: var(--dk-drop), inset 0 -14px 26px rgba(0,0,0,0.42);
  padding: 2.6% 5.5% 3%;
  width: min(100%, 470px); margin-inline: auto;
  display: flex; flex-direction: column; align-items: center; gap: 6px;
}
.forge2 .f2-shell::before {
  content: ""; position: absolute; inset: 7%; border-radius: inherit;
  border: 2.5px solid rgba(36,19,53,0.5); pointer-events: none;
}
/* Ten thousand years of student graffiti, scratched into her plastron.
   ROUND-8 FIX PASS: IT IS NOT TYPE ANY MORE, and that ends an argument this
   file has now had three times. Round 4 faded it to 15% ink and measured 1.84:1
   — text a reader's eye tries to resolve and cannot. Round 6 cut it deeper,
   wrote down the right rule ("either it is readable or it should not be type"),
   and then took the readable branch. Round 7 measured what actually shipped:
   到此一游 3.68:1 and 三年二班 3.70:1 at 14px, identical in dark and light, at
   rest (44 runs) and after a full carve (54 runs) — prom/dev/ui7-contrast.mjs
   and ui7-played.mjs, freeze-first. Two floors broken at once: 20px for hanzi,
   4.5:1 for body.
   Readable is the WRONG branch on this board, for the reason 历史课 hit first
   (commit 3dda063): at 375px these scratches sit directly beside the carving
   frame, so three legible strings of decorative Chinese are competing with the
   two characters the drill exists to make you read. The density rule and the
   type rule point the same way, and both point away from keeping the joke.
   So a scratch is drawn as a MARK, which is what a scratch is — tallies, a
   scratched-out shape, a zigzag, a scribble and idle hairlines, geometry in
   SCRATCH_D in forge2.js. No glyph, no font size, no contrast ratio to fail,
   three text runs off the board, and PLAINLY VISIBLE: each mark is cut dark
   with the pale material of the shell lipping out from under it, which is how
   every other cut on this stage is drawn (the groove, the frame, the sockets).
   The character keeps her joke — Wan says 「壳会长」 when you crack it. */
.forge2 .f2-graffiti { position: absolute; inset: 0; pointer-events: none; overflow: hidden; border-radius: inherit; }
.forge2 .f2-scratch { position: absolute; inset: 0; width: 100%; height: 100%; display: block; }
/* non-scaling-stroke is what keeps a scratch a scratch: the plastron is a
   different shape on a desk than on a phone and the marks stretch with it, but
   the width of the cut never changes, so they never thicken into stripes. */
.forge2 .f2-scratch path {
  fill: none; vector-effect: non-scaling-stroke;
  stroke-linecap: round; stroke-linejoin: round;
}
/* ON A DARK SHELL A CUT READS BY ITS LIP, NOT BY ITS SHADOW, and that is
   arithmetic rather than taste: the plastron's side margin composites to about
   rgb(74,58,36), so even a pure-black gouge there tops out at 1.92:1 and there
   is no alpha that makes the shadow the loud half of the mark. The pale
   material lipping out of the cut is what the eye catches. Measured by
   prom/dev/fg8-measure.mjs, identical in both themes: cut 1.48:1 and lip 1.70:1
   against the plastron, 2.52:1 across the mark edge to edge. That last number
   is the one an eye resolves as a scratch, and it is what a scratch on a
   ten-thousand-year-old shell should read as — visible, and never mistaken for
   something to read. */
/* THESE ALPHAS DO NOT MOVE, and round 11 tried. The blind judge's clutter note
   is that "the brown slab has faint etched doodles drawn in the same weight and
   colour as the actual dashed frame I'm supposed to use, so decoration and
   interface look identical" — a real finding, and the obvious fix is to push
   the marks down. Measured, that fix takes the cut to 1.39:1, the lip to 1.39:1
   and the mark edge-to-edge to 1.94:1, which is all three of the floors round 8
   set here (fg8-measure.mjs asserts cut >= 1.4, lip >= 1.55, swing >= 2.5) — a
   mark that quiet is not a quieter scratch, it is a scratch that has stopped
   being visible, which is the failure the numbers above exist to prevent.
   So the gap is widened from the OTHER side only: the frame steps forward (see
   .f2-frame), and the one mark the judge actually mistook for a control — the
   circle with an X through it, "my instinct is that it's a close button" — has
   stopped being that shape at all (SCRATCH_D in forge2.js). Decoration and
   interface are told apart by weight and by shape now, not by dimming the art. */
.forge2 .f2-scratch .f2-cut path { stroke: rgba(10,5,1,0.62); stroke-width: 2; }
.forge2 .f2-scratch .f2-lip path { stroke: rgba(231,215,174,0.34); stroke-width: 1.5; }

/* the shell IS the completion meter — principle 7 */
/* THE COLLECTION, and it is no longer this drill's own. It was a session-local
   chip row that emptied at the curtain; it is now the kit's `.dk-shell` strip
   (drill-kit.css) over the persistent store in prom/js/drills/shell2.js — ONE
   shell of 23 characters shared with 符咒课 Talisman Craft, which is what this
   drill's benchmark entry asks for in as many words. The bone-not-gold rule the
   old .f2-chip comment wrote down moved into the kit with it.
   What stays here is only the strip's fit ON THE PLASTRON: it is banded across
   the top of a 470px painted object with a hard height, so it never grows and
   never steals a pixel from the carving frame under it however full it gets. */
.forge2 .dk-shell {
  /* IT HAS TO FIT INSIDE THE CURVE. The plastron's top corners are
     border-radius 40%/30%, so a full-width band 16px down from the top hangs 64
     PIXELS PER SIDE out over the art — measured by prom/dev/sh7-fit.mjs, which
     solves the ellipse at the band's own two edges and compares. Dropped 14px
     and narrowed to 80%, the worst inset the curve asks for is 59px and the
     band has 68px, so both corners land on shell. That probe stays green or
     this rectangle is sitting on the painting again. */
  width: 80%; margin: 14px auto 0; padding: 3px 9px 4px; gap: 9px; border-radius: 9px;
  /* A CUT TROUGH, not a floating label. At the kit's scrim alpha the band read
     as haze over the plastron's own radial gradient — near-black at the left
     margin, brown in the middle — so it was a rectangle of nothing rather than
     an object. Flat, darker, and lipped: ink inside, the pale material of the
     shell catching the top edge, which is how every other cut on this board is
     drawn (the groove, the frame, the graffiti). */
  background: rgba(18, 9, 3, 0.66);
  box-shadow: inset 0 2px 5px rgba(0, 0, 0, 0.55), 0 1px 0 rgba(231, 215, 174, 0.20);
}
.forge2 .dk-shell-hd { gap: 6px; }
.forge2 .dk-shellchip { width: 1.35em; height: 1.35em; }
/* THE 0/23 CAPTION IS GONE (Lau, 2026-08-08) — "你刻的字 · 两门课共用 / carved
   by you, in both classes" was clutter on the shell itself, not a fact anyone
   needed mid-round. The strip is uncaptioned here now; no .dk-shell-cap markup
   is ever built for this drill, so nothing here styles it. */

/* ------------------------------------------------------- the carving frame */
/* The geometry IS the character's structure. 左右 is two cells side by side,
   上下 is two stacked, 品字 is one over two, 半包围 is a box holding a box —
   so the player reads the SHAPE of the frame and knows where the parts go.
   The wrapper holds the row's height so the fusion (which shrinks the frame
   onto the finished character) never reflows anything under it. */
.forge2 .f2-framewrap {
  width: 100%; height: var(--f2-frame);
  display: grid; place-items: center;
}
.forge2 .f2-frame {
  position: relative;
  width: var(--f2-frame); height: var(--f2-frame);
  /* THE FRAME IS INTERFACE AND HAS TO OUTREAD THE DECORATION AROUND IT. It sat
     at 0.5 on a plastron carrying scratches at a comparable weight, and the
     blind judge's first-action answer ended "I nearly missed the dashed frame
     entirely because it's dim brown-on-brown" — on the one object the legend's
     own sentence points at ("drag a stone into the frame"). Up to 0.66 at rest,
     with the 田字格 guides lifted with it so the inside of the frame reads as
     ruled paper rather than haze. The .ready state stays a clear step above
     (0.9 plus a 3px halo), so the "all parts seated" report is still a change
     the eye catches, and gold still belongs to the tool and not to this. */
  background-color: rgba(231,215,174,0.12);
  border: 3px solid rgba(231,215,174,0.66);
  border-radius: 6px;
  display: grid; gap: 3px; padding: 5px;
  /* the 田字格 guides, faint */
  background-image:
    linear-gradient(to right, rgba(231,215,174,0.22) 1.5px, transparent 1.5px),
    linear-gradient(to bottom, rgba(231,215,174,0.22) 1.5px, transparent 1.5px);
  background-size: 50% 50%; background-position: center;
  transition: width 0.42s cubic-bezier(.2,1,.3,1), height 0.42s cubic-bezier(.2,1,.3,1),
    border-color 0.3s, box-shadow 0.3s;
}
/* ALL PARTS SEATED. This is a REPORT, not a request — the thing the player has
   to act on the instant the last stone lands is the chisel, not the frame — so
   it reads in bone, the same material the seated parts are cut in, and the gold
   goes to the tool. It used to take the live token and keep it through the
   carve and the seal, so the bench carried three gold objects at once and none
   of them was the one to touch. */
.forge2 .f2-frame.ready { border-color: rgba(231,215,174,0.9); box-shadow: 0 0 0 3px rgba(231,215,174,0.22); }
.forge2 .f2-frame.form-lr  { grid-template-columns: 1fr 1fr; grid-template-rows: 1fr; }
.forge2 .f2-frame.form-tb  { grid-template-columns: 1fr; grid-template-rows: 1fr 1fr; }
.forge2 .f2-frame.form-tri { grid-template-columns: 1fr 1fr; grid-template-rows: 1fr 1fr;
  grid-template-areas: "top top" "bl br"; }
.forge2 .f2-frame.form-tri .cell-top { grid-area: top; }
.forge2 .f2-frame.form-tri .cell-bl  { grid-area: bl; }
.forge2 .f2-frame.form-tri .cell-br  { grid-area: br; }
.forge2 .f2-frame.form-enc { grid-template-columns: 1fr; grid-template-rows: 1fr; }
.forge2 .f2-frame.form-enc .cell-outer { grid-area: 1 / 1; border-width: 5px; }
/* 半包围: the outer part goes in the RING, not in the middle — the middle is
   what it encloses. Both cells used to hold a full-size glyph at the SAME
   --f2-glyph size, stacked in the same grid cell — which is not nesting, it is
   printing 门 and 口 on top of each other at equal weight, so 问 read as an
   overlap instead of one part sitting inside the other (Lau, 2026-08-08). The
   inner part is smaller now and sits in its own small plate — boxed, inset
   further, and drawn with a fraction of the outer's size — so it reads as
   something the outer part is HOLDING, the way 口 actually sits inside 门's
   own strokes, rather than competing with them for the same pixels. */
.forge2 .f2-frame.form-enc .cell-inner {
  grid-area: 1 / 1; margin: 34% 30% 18%; z-index: 1;
  background: rgba(0, 0, 0, 0.4); border-radius: 4px;
  box-shadow: inset 0 2px 6px rgba(0, 0, 0, 0.55), 0 0 0 1.5px rgba(231, 215, 174, 0.28);
}
.forge2 .f2-frame.form-enc .cell-inner .f2-set { font-size: calc(var(--f2-glyph) * 0.5); }

.forge2 .f2-cell {
  position: relative; display: flex; align-items: center; justify-content: center;
  border: 2.5px dashed rgba(231,215,174,0.44); border-radius: 5px;
  min-width: 0; min-height: 0; cursor: pointer;
  transition: background 0.16s, border-color 0.16s;
}
.forge2 .f2-cell.gk-zone-live { border-color: rgba(255,200,74,0.6); }
.forge2 .f2-cell.gk-zone-hot { border-color: var(--dk-gold); background: rgba(255,200,74,0.16); }
.forge2 .f2-cell.full { border-style: solid; border-color: rgba(231,215,174,0.62); background: rgba(0,0,0,0.24); }
.forge2 .f2-cell .f2-set {
  font-size: var(--f2-glyph); font-weight: 900; color: #ffe9b0; line-height: 1;
  text-shadow: 0 2px 0 rgba(0,0,0,0.5);
  animation: f2Set 0.34s cubic-bezier(.2,1,.3,1);
}
@keyframes f2Set { 0% { transform: scale(1.4) translateY(-10px); opacity: 0; } 60% { transform: scale(0.94); } }

/* the fusion beat: the cells merge into one and the frame tightens around the
   finished character, then the chip lifts onto the shell */
.forge2 .f2-frame.sealing { animation: f2Fuse 0.5s cubic-bezier(.2,1,.3,1); }
@keyframes f2Fuse { 40% { filter: brightness(2.4); } }
.forge2 .f2-frame.sealed {
  width: calc(var(--f2-glyph) * 1.7); height: calc(var(--f2-glyph) * 1.7);
  border-color: var(--dk-jade); box-shadow: 0 0 0 3px rgba(62,230,196,0.35);
  grid-template-columns: 1fr; grid-template-rows: 1fr; place-items: center;
}
.forge2 .f2-final {
  font-size: var(--f2-glyph); font-weight: 900; color: #ffe9b0; line-height: 1;
  text-shadow: 0 3px 0 rgba(0,0,0,0.55), 0 0 26px rgba(255,200,74,0.6);
  animation: f2Carve 0.6s cubic-bezier(.2,1,.3,1);
}
@keyframes f2Carve { 0% { opacity: 0; transform: scale(0.55) rotate(-6deg); } 65% { transform: scale(1.12); } }
.forge2 .f2-frame.crumbled { border-color: var(--dk-verm); }
/* .shallow / .cracked were the two DEPTH misses and nothing reaches them now
   that the carve grades no count (forge2.js judge). Kept: .crumbled is the one
   failure picture and it shares f2Slip. */
.forge2 .f2-frame.shallow { border-color: var(--dk-verm); }
.forge2 .f2-frame.shallow .f2-set { animation: f2Slip 0.62s cubic-bezier(.45,0,.75,1) forwards; }
@keyframes f2Slip {
  30% { transform: translateY(3px) rotate(-2deg); }
  100% { transform: translateY(34px) rotate(9deg); opacity: 0.18; }
}
.forge2 .f2-frame.cracked { border-color: var(--dk-verm); }
.forge2 .f2-frame.cracked::after {
  content: ""; position: absolute; inset: -4px; pointer-events: none;
  background: linear-gradient(105deg, transparent 46%, rgba(224,74,58,0.85) 47%, rgba(224,74,58,0.85) 49%, transparent 50%),
              linear-gradient(72deg, transparent 61%, rgba(224,74,58,0.7) 62%, rgba(224,74,58,0.7) 63.5%, transparent 64.5%);
}

.forge2 .f2-form { display: flex; align-items: baseline; gap: 8px; color: var(--paper, #f2efe9); }
/* 上下结构 / 左右结构 is a caption on the frame — it names the shape the two cells
   are already drawn in, and it does not change or ask for anything for the
   whole round. It was gold, i.e. the drill was pointing at a label while the
   thing the player has to act on is the empty frame above it and the tray to
   the right. Cream, one step up in weight from its own gloss, and the frame
   keeps the gold ring it earns when it is .ready. */
.forge2 .f2-form .han { color: var(--paper, #f2efe9); font-weight: 800; }
.forge2 .f2-form .dk-caption { color: rgba(242,239,233,0.78); }

/* ----------------------------------------------------------- the stone tray */
.forge2 .f2-side { display: flex; flex-direction: column; gap: 9px; align-items: center; }
.forge2 .f2-tray {
  width: 100%;
  /* five across, two rows. Nine stones in a 3x3 block pushed the side column
     100px taller than the shell, which is what put the reveal card through the
     middle of the tool row. */
  display: grid; grid-template-columns: repeat(5, minmax(0, 1fr)); gap: 7px;
  padding: 9px; border-radius: 14px;
  background: linear-gradient(180deg, rgba(24,12,38,0.85), rgba(16,8,28,0.92));
  border: 3px solid var(--dk-ink); box-shadow: var(--dk-drop);
}
.forge2 .f2-stone {
  cursor: grab; padding: 5px 3px 6px;
  display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 1px;
  background: radial-gradient(75% 70% at 35% 28%, var(--f2-stone), var(--f2-stone-2));
  border: 3px solid var(--dk-ink); border-radius: 40% 44% 38% 46% / 44% 38% 46% 40%;
  box-shadow: 0 4px 0 rgba(14,6,24,0.7);
  transition: transform 0.16s cubic-bezier(.2,1,.3,1), box-shadow 0.16s;
}
.forge2 .f2-stone .f2-glyph { font-size: var(--f2-glyph); font-weight: 900; color: var(--dk-ink); line-height: 1; }
/* the stroke count that used to sit under each glyph went with the arithmetic
   (see forge2.js paintTray) — the stone is the piece, and the glyph is all of it */
.forge2 .f2-stone:hover { transform: translateY(-4px); box-shadow: 0 8px 0 rgba(14,6,24,0.7); }
.forge2 .f2-stone:active { cursor: grabbing; }
.forge2 .f2-stone:focus-visible { outline: 3px solid var(--dk-gold); outline-offset: 3px; }
/* A STONE IN THE HAND. The tap path is pick-up-then-aim (see takeStone in
   forge2.js), so between the two taps there is an object off the tray and a
   frame waiting for it, and both have to be visible at once. The stone is told
   by MATERIAL — lifted clear of its socket, ringed in the same bone the seated
   parts are cut in, rocking the way a thing being carried does — and NOT by a
   second gold, because the gold on screen in that moment belongs to the cells
   it could go into (.f2-cell.gk-zone-live, the drag path's own affordance,
   which is the whole reason the tap path borrows it). */
.forge2 .f2-stone.in-hand {
  cursor: grabbing;
  transform: translateY(-7px) scale(1.04);
  box-shadow: 0 11px 0 rgba(14,6,24,0.72), 0 0 0 3px rgba(231,215,174,0.55);
  animation: f2Hold 1.4s cubic-bezier(.4,0,.6,1) infinite alternate;
}
@keyframes f2Hold { to { transform: translateY(-10px) scale(1.04) rotate(-1.8deg); } }
/* a stone that is in the frame is NOT on the tray: the slot is an empty socket.
   (It used to stay put at 22% opacity, which is unreadable text on screen —
   round-4 judging is right that a faded glyph is worse than no glyph.) */
.forge2 .f2-socket {
  border-radius: 40% 44% 38% 46% / 44% 38% 46% 40%;
  background: rgba(0,0,0,0.34);
  box-shadow: inset 0 3px 7px rgba(0,0,0,0.6);
  border: 2.5px dashed rgba(231,215,174,0.22);
}

/* --------------------------------------------------------------- the tools */
.forge2 .f2-tools { display: flex; align-items: stretch; gap: 10px; flex-wrap: wrap; justify-content: center; }
.forge2 .f2-tool {
  display: flex; align-items: center; gap: 9px;
  background: var(--dk-stock); color: var(--dk-ink);
  border: 3px solid var(--dk-ink); border-radius: 999px;
  padding: 6px 18px 6px 9px; cursor: pointer;
  box-shadow: var(--dk-drop);
  transition: transform 0.14s cubic-bezier(.2,1,.3,1), box-shadow 0.14s, background 0.2s;
  touch-action: none;
}
.forge2 .f2-tool svg { width: 38px; height: 38px; display: block; flex: none; }
/* 再读一遍 reads as an icon alone — see AGAIN_ICON — so its button drops the
   name-plate padding and just centers the glyph. */
.forge2 .f2-tool-ic { padding: 9px; }
.forge2 .f2-tool-ic svg { width: 26px; height: 26px; }
/* THE TOOL'S NAME, IN BOTH SCRIPTS, STACKED — and nothing about how to use it.
   Round 6 took the English off these two buttons because "hold to cut" and
   "seal it" repeated the legend word for word. Round-10 judging found what that
   left behind: two icon buttons whose labels share a character, which a beginner
   reads as a pair of opposites with no way to tell which is safe ("I have no
   idea which is the safe one to press"). The legend cannot cover this — at the
   first frame it is talking about stones, and both tools are shut.
   So: the NOUN, at the label step, under the hanzi, the way every notice in this
   build is stacked. 「read it again」 and 「seal, final」 name the object and its
   consequence in four words total; the verb, the timing and the gesture stay in
   the legend, which is the only line on the board that changes. */
.forge2 .f2-tool-name { display: flex; flex-direction: column; align-items: flex-start; gap: 0; min-width: 0; }
.forge2 .f2-tool-txt { line-height: 1.12; color: var(--dk-ink); }
/* ink at 76%, not a lighter colour: the tool's face is --dk-stock (cream), so a
   faded label here would be dark-on-light losing contrast, not gaining quiet.
   0.76 of #241335 on cream still measures well past 4.5:1. */
.forge2 .f2-tool-en { line-height: 1.16; color: color-mix(in srgb, var(--dk-ink) 76%, transparent); }
/* A DISABLED TOOL IS AN INERT TOOL, NOT A FADED ONE. `opacity: .4` on the whole
   button dragged its own label down to 1.4:1 over the night stage (round-4
   judging measured 3.19–3.65:1 on the painting). The tool now goes cold — stone
   instead of cream, no lift, no shadow — and every glyph on it stays at full
   ink, so the face is as readable when it is waiting as when it is live. */
.forge2 .f2-tool:disabled {
  cursor: default; background: var(--f2-stone-2); box-shadow: none;
  transform: translateY(3px);
}
.forge2 .f2-tool:disabled svg { filter: grayscale(0.8); }
.forge2 .f2-tool.is-active { border-color: var(--dk-gold-deep); box-shadow: var(--dk-drop), 0 0 0 3px rgba(255,200,74,0.55); }
/* ONE RING, NOT TWO CONCENTRIC ONES. .is-active predates the kit's .dk-live and
   now always coincides with it on this board (both are set from refreshReady),
   so the button was wearing a 3px gold halo inside a 4px gold outline. The kit's
   ring is the one the census counts and the one every other drill uses, so it
   wins; .is-active keeps only the warm border, which is the part that reads on
   the object itself rather than around it. */
.forge2 .f2-tool.is-active.dk-live { box-shadow: var(--dk-drop); }
.forge2 .f2-tool:focus-visible { outline: 3px solid var(--dk-gold); outline-offset: 3px; }
.forge2 .f2-tool:not(:disabled):active { transform: translateY(4px) scale(0.97); box-shadow: 0 1px 0 rgba(14,6,24,0.75); }

/* THE LEGEND, now directly under the tray and under the ring (see forge2.js).
   It sits on its own material rather than on the painting (round-4 judging, and
   the kit's own rule) because it is the last line a lost player reads. */
/* 5px of clearance under the ring: .dk-live breathes its outline out to 10px and
   the column's own gap is 9, so at full breath the gold was landing on the
   legend's plate. */
.forge2 .f2-note { margin: 5px 0 0; text-align: center; }
/* .dk-legend sets display:block, which beats the UA sheet's [hidden] rule — so
   the legend has to be told explicitly to go away while the reveal card is up,
   or a sliver of it pokes out from behind the paper.
   VISIBILITY, NOT DISPLAY, since the move above put it BETWEEN the tray and the
   tools: collapsing it would jump the whole tool row up the instant a verdict
   lands, which is a 30px lurch under the player's hand at the exact moment they
   are being asked to read something. Invisible either way. */
.forge2 .f2-note[hidden] { display: block; visibility: hidden; }

/* ------------------------------------------------------------- the verdict */
/* The reveal is the teaching beat, so it may never sit below the fold — in flow
   it landed at y≈660 on a 900px stage and got clipped, and on a phone it was a
   screen and a half down. It is a slip of paper laid on the desk, which is a
   MATERIAL and not a floating HUD panel: pinned to the bottom of the stage,
   capped in height, scrollable if a long sentence ever needs it. */
.forge2 .f2-verdict {
  position: fixed; left: 50%; bottom: 12px; z-index: 45;
  width: min(660px, 94vw); margin: 0; padding: 7px 18px 9px;
  max-height: min(58vh, 440px); overflow-y: auto;
  border-radius: 12px; text-align: center;
  display: flex; flex-direction: column; align-items: center; gap: 1px;
  opacity: 0; transform: translate(-50%, 14px);
  transition: opacity 0.26s ease-out, transform 0.26s cubic-bezier(.2,1,.3,1);
}
.forge2 .f2-verdict.in { opacity: 1; transform: translate(-50%, 0); }
/* `display: flex` above beats the UA sheet's `[hidden] { display: none }`, so a
   dismissed card stayed in the layer at opacity 0 — invisible, and swallowing
   every pointerdown underneath it. At 1280 it sat over empty painting and hid
   the defect; at 390 it covers the entire stone bench, and rounds 2-5 became
   unplayable because no stone could be picked up. Two rules, not one. */
.forge2 .f2-verdict[hidden] { display: none; }
.forge2 .f2-verdict:not(.in) { pointer-events: none; }
/* THE ANSWER KEY IS NOT A VERDICT. Round-6 judging, verbatim: ".f2-verdict
   .is-wrong .f2-v-zh prints the target character (炎) in vermillion-deep at
   56px — the answer key in the wrong-answer ink." That is exactly the failure
   the palette rule exists to prevent, and it is worse than decorative: the one
   glyph on the card the player is meant to LEARN was painted in the colour this
   build uses to mean "this is the mistake", 56 pixels tall, for four seconds,
   on the round they got wrong. A learner who trusts the colour system reads it
   as "炎 is the wrong answer".
   So the character is ink in both outcomes — it is a fact, and a fact has no
   opinion about how the round went — and the semantic pair moves to the card's
   TOP EDGE, where a coloured band is the whole of its job. The verdict is also
   carried three other ways the player already sees: the frame goes jade and
   tightens or goes vermillion and cracks, ding() plays two different sounds,
   and Wan says which it was, in Chinese, on the panel above. */
.forge2 .f2-v-zh {
  font-size: var(--f2-glyph); font-weight: 900; line-height: var(--dk-lh-tight);
  color: var(--dk-ink);
}
.forge2 .f2-verdict.is-right { border-top: 6px solid var(--dk-jade-deep); }
.forge2 .f2-verdict.is-wrong { border-top: 6px solid var(--dk-verm-deep); }
.forge2 .f2-v-py { color: var(--dk-ink-soft); }
/* the sum, spelled out: 女三画 ＋ 子三画 ＝ 好六画 */
.forge2 .f2-v-sum {
  display: flex; align-items: flex-start; gap: 7px; flex-wrap: wrap; justify-content: center;
  margin-top: 8px;
}
.forge2 .f2-vp { display: flex; flex-direction: column; align-items: center; line-height: 1.2; }
.forge2 .f2-vp-top { display: flex; align-items: baseline; gap: 5px; }
/* ONE RULE ON THIS ROW: characters are ink, NUMBERS are QUIETER ink. The
   distinction is real typographic work — it tells the eye which half of
   「木 四画」 is the glyph and which half is the count — and it has to be made
   out of one hue, because the only other hues this build owns are the semantic
   three. It used to be made in #6d4f06, which is byte-identical to the kit's
   --dk-gold-deep: a colour census reported it as gold text, and a census is
   right to, because a reader who has learned "gold = act now" has no way to
   know this particular gold is a private accent. --dk-ink-soft is the kit's own
   "darkest quiet allowed" (5.4:1 on cream, measured 12.8:1 here against what is
   actually painted behind it), so the row is now ink and ink only. */
.forge2 .f2-vp .han { color: var(--dk-ink); }
.forge2 .f2-vp .dk-caption { color: var(--dk-ink-soft); }
.forge2 .f2-plus { color: var(--dk-ink-soft); font-size: var(--dk-read); align-self: center; }
.forge2 .f2-v-miss { color: var(--dk-ink); margin-top: 7px; }
/* the ONE vermillion on this card, and it is on the number that was wrong */
.forge2 .f2-v-miss .han { color: var(--dk-verm-deep); }
/* THE PRACTICE SEAL'S ONE EXTRA ROW. The walkthrough's 收刀 is performed on a
   scrap block, and "did that count?" is the only question a first-timer has at
   that moment — so the card answers it in both languages, stacked the way every
   notice in this build is (hanzi, English under it, never side by side). */
.forge2 .f2-v-note {
  display: flex; flex-direction: column; align-items: center; gap: 1px;
  margin-top: 8px; color: var(--dk-ink); text-align: center;
}
.forge2 .f2-v-note .dk-label { color: var(--dk-ink-soft); }
/* the practice card keeps the jade edge — the block WAS sealed cleanly; what it
   did not do is count, and that is the row's job, not the border's */
.forge2 .f2-verdict.is-practice { border-top-color: var(--dk-jade-deep); }

/* .f2-v-sent / .f2-v-en / .f2-v-wan are gone from the card on purpose — see the
   note in forge2.js judge(). The tell panel at the top of the same screen was
   already printing all three, word for word, at the same moment. */

/* ------------------------------------------------------------------ phones */
@media (max-width: 860px) {
  .forge2 .f2-body { grid-template-columns: 1fr; }
  .forge2 .f2-side { flex-direction: column; }
}
@media (max-width: 480px) {
  /* THE LEGEND HAS TO BE ON THE PHONE'S SCREEN. It is the line that names the
     next move — and now that 刻刀 and 收刀 have dropped their English captions
     it is the only place the verb is written — and at 390x844 the bench ran
     23px past the fold with the legend as the thing that fell off it. Every
     number below buys those pixels back out of AIR, never out of type: the
     frame gives up 4vw, the side column and the body grid give up a few px of
     gutter each, and the bench now ends above the fold with room to spare.
     Measured at 390x844: the legend's bottom sits inside the viewport in both
     themes, in every phase (prom/dev/fg6b-base.mjs).

     ROUND-8: THAT GUARANTEE WAS ONLY EVER TRUE OF A LUCKY DRAW, and the
     paragraph above should not have been written as though it held. fg6b-base
     opens a RANDOM round, and this panel's height swings by a whole 32px line
     depending on which sentence it drew: 「□天见！」 is four characters and
     「她有两个孩子，一个女孩，一个□孩。」 is seventeen and wraps. Re-measured on
     the random draw, the legend's bottom came back at 859 dark and 866 light
     against an 844 fold. prom/dev/fg8-fold.mjs forces the longest sentence, the
     longest caption and the caption already up — the real worst case — and
     measures that instead of a coin flip.
     Two things are fixed here and one is not.
     FIXED: the English legend had crept back to 45 characters. The plate it
     sits on is `max-width: min(46ch, 92vw)`, so on a narrow phone the vw half
     binds — 294px at 320 — and a 45-character line wraps to a second row, which
     costs a whole line at the fold. All four lines are 21-33 characters and
     185-276px wide now, and the probe fails on a wrap at any width. FIXED: air that
     accumulated across two rounds of additions comes back out of gutters and
     padding, NEVER out of type — the frame gives up 3vw and the shell, tray,
     stones, tell and gauge give up a few pixels of padding each, worth ~36px.
     Every type size on this board is byte-identical to what it was, and the
     collection strip keeps its 14px drop because prom/dev/sh7-fit.mjs solves the
     plastron's curve at exactly that offset.
     NOT FIXED, and it is not a padding problem: with the longest sentence in the
     bank on the panel the bench still runs past the fold — by 8px at 390 dark,
     15px at 390 light, 54-61px at 375 and 105-127px at 320. This board is a
     tell panel plus a plastron plus a nine-stone tray plus a tool row, and on a
     320-tall-by-720 phone that is 145px more than exists. It is a density
     question for a round that can spend the time (the tray is the obvious
     candidate — nine stones in two rows is 161px), not something another 4px of
     padding reaches. The drill scrolls, so the legend is a thumb-flick away
     rather than lost, and the seal — the control that actually has to be
     reachable — is above it at every width. */
  .minigame.forge2 { --f2-frame: min(192px, 35vw); gap: 5px; padding-top: 6px; }
  .forge2 .f2-body { gap: 9px; }
  .forge2 .f2-side { gap: 6px; }
  .forge2 .f2-tray { gap: 5px; padding: 6px; }
  .forge2 .f2-stone { padding: 3px 2px 5px; }
  .forge2 .f2-shell { border-radius: 26px; padding: 8px 10px 7px; gap: 4px; }
  .forge2 .f2-tell { padding: 6px 12px 5px; }
  .forge2 .f2-court { gap: 4px; }
  .forge2 .dk-shell { padding: 2px 6px; gap: 6px; }
  /* the reveal card has to clear the carving frame on a phone too, so it is
     tighter here — every row keeps its type size, only the air goes */
  .forge2 .f2-verdict { bottom: 8px; padding: 6px 12px 8px; gap: 0; max-height: min(52vh, 400px); }
  .forge2 .f2-v-sum { margin-top: 5px; gap: 5px; }
  .forge2 .f2-v-miss { margin-top: 5px; }
  .forge2 .f2-tool { padding: 4px 13px 4px 7px; gap: 7px; }
  .forge2 .f2-tool svg { width: 28px; height: 28px; }
  .forge2 .f2-tools { gap: 8px; }
}

/* ------------------------------------------------------ reduced motion */
@media (prefers-reduced-motion: reduce) {
  .forge2 .f2-stone, .forge2 .f2-tool, .forge2 .f2-cell,
  .forge2 .f2-verdict, .forge2 .f2-en, .forge2 .f2-frame { transition: none; }
  .forge2 .f2-say.pop, .forge2 .f2-cell .f2-set, .forge2 .f2-gap.on,
  .forge2 .f2-frame.sealing, .forge2 .f2-final,
  .forge2 .f2-frame.shallow .f2-set { animation: none; }
  /* the rocking is motion; "this stone is in your hand" is information, so the
     lift and the bone ring stay and only the rock goes */
  .forge2 .f2-stone.in-hand { animation: none; }
  /* the slide-off is motion; the fact that the parts did not hold is not, so
     reduced motion keeps the vermillion frame and simply drops them a little */
  .forge2 .f2-frame.shallow .f2-set { opacity: 0.35; }
  .forge2 .f2-verdict { opacity: 1; transform: translate(-50%, 0); }
  .forge2 .f2-en.in { opacity: 1; }
}

/* ------------------------------------------------------- the kit's flourish
   `burst()` is parked dead centre of the stage by prom.css (top:38%), which in
   this drill is exactly where the object the round is about lives — the badge
   landed on top of a control every time. Move it into the empty lower corner
   opposite the host and give it a material, so it reads as a stamp rather than
   as loose text over the painting.

   The badge is TEAL, not gold. 「刻上了」 is emitted from exactly one place in
   forge2.js — the `ok` branch of judge(), after a correct seal — so it says
   "correct", which is teal's whole and only meaning. It was gold, the token for
   "act now", fired at the one moment in the round when the player has nothing
   left to do. It now matches the jade ring the frame takes on the same beat. */
.forge2 .mg-burst:not(.streak) {
  left: auto; right: 3%; top: auto; bottom: 8%; transform: none;
  padding: 4px 14px 6px; border-radius: 10px;
  background: rgba(18, 9, 30, 0.92); border: 2.5px solid var(--dk-ink);
  box-shadow: var(--dk-drop); color: var(--dk-jade);
  animation: forge2Burst 0.42s cubic-bezier(.2, 1, .3, 1);
}
.forge2 .mg-burst:not(.streak) .han, .forge2 .mg-burst:not(.streak) b {
  font-size: var(--dk-read); font-weight: 900; color: var(--dk-jade);
}
@keyframes forge2Burst { 0% { opacity: 0; transform: translateY(16px) scale(0.86); } }
@media (prefers-reduced-motion: reduce) { .forge2 .mg-burst:not(.streak) { animation: none; } }
/* On a phone the reveal card owns the entire bottom of the stage, and the
   lower-right corner this stamp was moved into at 1280 is directly underneath
   it — so the one flourish that marks a correct carve fired invisibly, behind
   the paper, on every success. Caught by looking at a 390 screenshot, not by a
   probe. It moves onto the empty top-right of her shell instead, which is
   where a stamp belongs anyway. */
@media (max-width: 480px) {
  .forge2 .mg-burst:not(.streak) { right: 4%; bottom: auto; top: 26%; }
}

/* -------------------------------------------------------- 阿霞's speech bubble
   HER LINE IN ENGLISH (bilingual pass), same recipe as cloze2's .c2-en and
   clinic2's own bubble support line: one label-step line under the hanzi, ink
   on the bubble's own cream paper, never a gloss of the round itself (the
   sentence-with-a-hole and its de-blurring caption are .f2-quiz/.f2-en, board
   state, not speech — see the note above .f2-tell). */
.minigame.forge2 .mg-bubble .f2-say-en {
  display: block; margin-top: 3px; font-style: normal;
  font-size: var(--dk-label); font-weight: 700; line-height: 1.25;
  color: #241335; opacity: 0.88;
}
/* THE HOST'S OWN LANE. stageHTML's host art pins to the stage's bottom-left —
   the same corner .f2-shell already owns — so without a reserved column her
   painted card would sit on top of the shell instead of beside it. Reserve a
   lane as wide as her card plus its capped bubble and pad the whole drill out
   of it, the same fix cloze2's ROUND-4 note wrote down first for exactly this
   collision (a host's art landing on the board's own reading surface). */
@media (min-width: 721px) {
  .minigame.forge2 {
    --f2-host-h: min(40vh, 30vw);
    --f2-host-lane: calc(30px + 0.4 * var(--f2-host-h) + min(24vw, 230px));
    padding-left: var(--f2-host-lane);
  }
  .minigame.forge2 .mg-host { height: var(--f2-host-h) !important; }
  .minigame.forge2 .mg-bubble { max-width: min(24vw, 230px); }
}
/* Under 721px prom.css takes the cutout off stage and minigames.js floats the
   bubble into the page flow above the court (crew.preFloat, wired in
   forge2.js), so there is no lane to reserve and nothing to overlap. */

/* Packet 09: placement names belong to the stone cells, not a distant legend. */
.forge2 .f2-cell { background: transparent; color: var(--dk-ink); font: inherit; border-radius: 2px; min-width: 44px; min-height: 44px; padding: 0; }
.forge2 .f2-cell-label { position: absolute; top: 3px; left: 3px; right: 3px; z-index: 3; font: 600 0.8rem/1.15 var(--sans, sans-serif); color: var(--dk-ink); background: var(--dk-stock); pointer-events: none; }
.forge2 .f2-cell.full .f2-cell-label { top: auto; bottom: 2px; }
.forge2 .cell-outer .f2-cell-label { right: auto; }
.forge2 .mg-head { flex-wrap: wrap; height: auto; }

.forge2 .f2-next { display: block; min-height: 44px; margin: 12px auto 0; padding: 8px 12px; color: var(--dk-ink); background: var(--dk-stock); font: 600 1rem/1.3 system-ui; }

/* Counters must wrap inside their own paper, including enlarged text. */
.minigame.forge2 .mg-score { min-width: 0; max-width: 100%; white-space: normal; overflow-wrap: anywhere; }
.minigame.forge2 .mg-score .dk-goal { min-width: 0; max-width: 100%; flex-wrap: wrap; white-space: normal; }
.minigame.forge2 .mg-score .dk-goal-en { white-space: normal; overflow-wrap: anywhere; }
@media (max-width: 430px) {
  body .minigame.forge2.has-manual > .mg-head { padding: 56px 12px 10px !important; }
}
