pi-mega-compact 0.7.8 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mega-compact",
-  "version": "0.7.8",
+  "version": "0.8.0",
   "description": "Layered, local, vector-backed context compressor for pi — supersede/collapse/cluster compaction with deduped inline recall.",
   "type": "module",
   "license": "BSD-2-Clause",
@@ -41,15 +41,16 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "lint": "tsc --noEmit && node scripts/guardrails-scan.mjs",
+    "lint": "tsc --noEmit && node scripts/guardrails-scan.mjs && node scripts/semantic-scan.mjs",
     "test": "npm run build && node scripts/run-tests.mjs",
-    "guardrails": "python3 scripts/regression_check.py --all || node scripts/guardrails-scan.mjs",
+    "guardrails": "python3 scripts/regression_check.py --all || node scripts/guardrails-scan.mjs || node scripts/semantic-scan.mjs",
     "precommit": "bash .claude/hooks/pre-commit.sh",
     "prepublishOnly": "npm run build",
     "postinstall": "npm rebuild @mongodb-js/zstd || true"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": ">=0.80",
     "openclaw": ">=0.1.0"
   },
   "devDependencies": {

package/src/config/themes.test.ts

@@ -0,0 +1,116 @@
+/**
+ * themes.test.ts — S30 theme palette source-of-truth tests.
+ * Pi-agnostic: no pi runtime imports.
+ */
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import {
+  THEMES,
+  THEME_IDS,
+  DEFAULT_THEME,
+  getTheme,
+  isValidTheme,
+  nextTheme,
+  themeCssVars,
+  themeDataBlock,
+} from "./themes.js";
+
+describe("themes (S30)", () => {
+  it("defines exactly 6 themes", () => {
+    assert.equal(THEMES.length, 6);
+    assert.equal(THEME_IDS.length, 6);
+  });
+
+  it("has unique ids", () => {
+    assert.equal(new Set(THEME_IDS).size, 6);
+  });
+
+  it("default theme is transparent", () => {
+    assert.equal(DEFAULT_THEME, "transparent");
+    assert.ok(isValidTheme(DEFAULT_THEME));
+  });
+
+  it("includes retro, orange-bold, cyan-neon, amber-mono, grayscale", () => {
+    for (const id of ["retro", "orange-bold", "cyan-neon", "amber-mono", "grayscale"]) {
+      assert.ok(isValidTheme(id), `missing ${id}`);
+    }
+  });
+
+  it("transparent theme has null bg (CSS + ANSI)", () => {
+    const t = getTheme("transparent");
+    assert.ok(t);
+    assert.equal(t!.css.bg, null);
+    assert.equal(t!.ansi.bg, null);
+  });
+
+  it("every non-transparent theme has a non-null bg", () => {
+    for (const t of THEMES) {
+      if (t.id === "transparent") continue;
+      assert.ok(t.css.bg, `${t.id} css.bg`);
+      assert.ok(t.ansi.bg, `${t.id} ansi.bg`);
+    }
+  });
+
+  it("every theme has css + ansi {fg,accent,mega} strings", () => {
+    for (const t of THEMES) {
+      assert.ok(typeof t.css.fg === "string" && t.css.fg.startsWith("#"));
+      assert.ok(typeof t.css.accent === "string");
+      assert.ok(typeof t.css.mega === "string");
+      assert.ok(typeof t.ansi.fg === "string");
+      assert.ok(typeof t.ansi.accent === "string");
+      assert.ok(typeof t.ansi.mega === "string");
+    }
+  });
+
+  it("getTheme returns undefined for unknown id", () => {
+    assert.equal(getTheme("nope"), undefined);
+  });
+
+  it("isValidTheme is false for unknown", () => {
+    assert.equal(isValidTheme("nope"), false);
+  });
+
+  it("nextTheme cycles through all themes and wraps", () => {
+    const seen: string[] = [];
+    let cur = DEFAULT_THEME;
+    for (let i = 0; i < THEME_IDS.length; i++) {
+      cur = nextTheme(cur);
+      seen.push(cur);
+    }
+    // after N steps we've visited every theme once
+    assert.equal(new Set(seen).size, THEME_IDS.length);
+    // wraps: one more step from the last returns to the first
+    const first = nextTheme(THEME_IDS[THEME_IDS.length - 1]!);
+    assert.equal(first, THEME_IDS[0]);
+  });
+
+  it("nextTheme falls back to DEFAULT_THEME for unknown current", () => {
+    assert.equal(nextTheme("garbage"), DEFAULT_THEME);
+  });
+});
+
+describe("themeCssVars / themeDataBlock (S32)", () => {
+  it("themeCssVars emits --bg/--fg/--accent/--mega for a normal theme", () => {
+    const t = getTheme("retro")!;
+    const vars = themeCssVars(t);
+    assert.match(vars, /--bg: #003300;/);
+    assert.match(vars, /--fg: #33ff33;/);
+    assert.match(vars, /--accent: #00ff41;/);
+    assert.match(vars, /--mega: #39ff14;/);
+  });
+
+  it("themeCssVars maps null bg to 'transparent'", () => {
+    const t = getTheme("transparent")!;
+    const vars = themeCssVars(t);
+    assert.match(vars, /--bg: transparent;/);
+    assert.match(vars, /--fg: #c9d1d9;/);
+  });
+
+  it("themeDataBlock wraps vars in a :root[data-theme=\"<id\"] selector", () => {
+    const t = getTheme("cyan-neon")!;
+    const block = themeDataBlock(t);
+    assert.equal(block.startsWith(':root[data-theme="cyan-neon"]{ '), true);
+    assert.equal(block.endsWith(" }"), true);
+    assert.ok(block.includes("--accent: #22d3ee;"));
+  });
+});

package/src/config/themes.ts

@@ -0,0 +1,124 @@
+/**
+ * themes.ts — SINGLE SOURCE OF TRUTH for game-mode visual-effect themes (S30).
+ *
+ * Each theme defines BOTH an HTML/CSS palette (dashboard) AND an ANSI accent
+ * mapping (TUI widget), since the TUI is ANSI and the dashboard is HTML.
+ *
+ * Theme scope (QA1 correction): themes restyle the mega-compact statusbar
+ * widget + the whole dashboard HTML page. We do NOT theme pi's chrome.
+ *
+ * `transparent` (default) semantics: no background fill, colored accents only —
+ * so game-mode stays visible against any terminal background.
+ *
+ * PREVENT-PI-004: pure config, no network. Pi-agnostic: no pi runtime types.
+ */
+
+/** HTML/CSS palette for the dashboard (hex strings, or `null` for "no bg"). */
+export interface ThemeCss {
+  /** Page/cell background hex, or `null` for transparent (no bg fill). */
+  bg: string | null;
+  /** Default foreground (text) hex. */
+  fg: string;
+  /** Accent hex (bars, highlights, level numbers). */
+  accent: string;
+  /** MEGA CACHE highlight hex (fires at cache >= 100%). */
+  mega: string;
+}
+
+/** ANSI accent mapping for the TUI widget (SGR parameter strings, no `\x1b[`).
+ *  `bg` is `null` for transparent themes (no background fill). */
+export interface ThemeAnsi {
+  /** Background SGR params (e.g. "48;5;23"), or `null` for no bg fill. */
+  bg: string | null;
+  /** Foreground SGR params (e.g. "39" for default, "92" for bright green). */
+  fg: string;
+  /** Accent SGR params. */
+  accent: string;
+  /** MEGA CACHE SGR params (fires at cache >= 100%). */
+  mega: string;
+}
+
+/** A complete theme = CSS palette + ANSI mapping + display metadata. */
+export interface Theme {
+  id: string;
+  label: string;
+  css: ThemeCss;
+  ansi: ThemeAnsi;
+}
+
+export const DEFAULT_THEME = "transparent";
+
+export const THEMES: readonly Theme[] = [
+  {
+    id: "transparent",
+    label: "Transparent (accents only)",
+    css: { bg: null, fg: "#c9d1d9", accent: "#3fb950", mega: "#f0883e" },
+    ansi: { bg: null, fg: "39", accent: "32", mega: "33" },
+  },
+  {
+    id: "retro",
+    label: "Retro 8-bit green",
+    css: { bg: "#003300", fg: "#33ff33", accent: "#00ff41", mega: "#39ff14" },
+    ansi: { bg: "40", fg: "92", accent: "92", mega: "1;92" },
+  },
+  {
+    id: "orange-bold",
+    label: "Orange bold",
+    css: { bg: "#1a0f00", fg: "#ff8c00", accent: "#ff6b00", mega: "#ff4500" },
+    ansi: { bg: "48;5;52", fg: "38;5;208", accent: "38;5;208", mega: "1;38;5;202" },
+  },
+  {
+    id: "cyan-neon",
+    label: "Cyan neon",
+    css: { bg: "#001a1a", fg: "#00ffff", accent: "#22d3ee", mega: "#7df9ff" },
+    ansi: { bg: "48;5;23", fg: "38;5;51", accent: "38;5;51", mega: "1;38;5;51" },
+  },
+  {
+    id: "amber-mono",
+    label: "Amber phosphor",
+    css: { bg: "#1a1200", fg: "#ffb000", accent: "#ff8c00", mega: "#ff5500" },
+    ansi: { bg: "48;5;58", fg: "38;5;214", accent: "38;5;214", mega: "1;38;5;208" },
+  },
+  {
+    id: "grayscale",
+    label: "Grayscale minimal",
+    css: { bg: "#161616", fg: "#b0b0b0", accent: "#8b949e", mega: "#e6edf3" },
+    ansi: { bg: "48;5;235", fg: "38;5;249", accent: "38;5;249", mega: "1;38;5;255" },
+  },
+] as const;
+
+/** All valid theme ids, in definition order (used for `theme next` cycling). */
+export const THEME_IDS: readonly string[] = THEMES.map((t) => t.id);
+
+/** Look up a theme by id; returns `undefined` for an unknown id (caller
+ *  validates + falls back to DEFAULT_THEME). */
+export function getTheme(id: string): Theme | undefined {
+  return THEMES.find((t) => t.id === id);
+}
+
+/** True if `id` is a known theme id. */
+export function isValidTheme(id: string): boolean {
+  return THEME_IDS.includes(id);
+}
+
+/** Cycle to the next theme id (wraps at the end). Falls back to DEFAULT_THEME
+ *  if `current` is unknown (defensive — the stored id should always be valid). */
+export function nextTheme(current: string): string {
+  const i = THEME_IDS.indexOf(current);
+  if (i < 0) return DEFAULT_THEME;
+  return THEME_IDS[(i + 1) % THEME_IDS.length]!;
+}
+
+/** CSS variable declarations for a theme's CSS palette. `bg` is `null` for the
+ *  transparent theme → `--bg: transparent` (no page fill, accents only). Pure,
+ *  no pi types. */
+export function themeCssVars(theme: Theme): string {
+  const bg = theme.css.bg ?? "transparent";
+  return `--bg: ${bg}; --fg: ${theme.css.fg}; --accent: ${theme.css.accent}; --mega: ${theme.css.mega};`;
+}
+
+/** A `:root[data-theme="<id>"]` override block carrying the theme's CSS vars,
+ *  for client-side instant theme switching. Pure, no pi types. */
+export function themeDataBlock(theme: Theme): string {
+  return `:root[data-theme="${theme.id}"]{ ${themeCssVars(theme)} }`;
+}

package/src/game/scoring.test.ts

@@ -0,0 +1,103 @@
+/**
+ * scoring.test.ts — S33 pure scoring helpers. Pi-agnostic, no I/O.
+ */
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { turnLevel, isMegaCache, cacheScore, evaluateAchievements, maxCompactCount, ACHIEVEMENT_DEFS } from "./scoring.js";
+import type { LeaderboardRow } from "../store/sqlite/game-scores.js";
+
+describe("scoring (S33)", () => {
+	it("turnLevel: floor(log2(n+1))+1 sequence", () => {
+		assert.equal(turnLevel(0), 1);
+		assert.equal(turnLevel(1), 2);
+		assert.equal(turnLevel(2), 2);
+		assert.equal(turnLevel(3), 3);
+		assert.equal(turnLevel(4), 3);
+		assert.equal(turnLevel(7), 4);
+		assert.equal(turnLevel(15), 5);
+		// defensive: non-finite / negative inputs collapse to level 1
+		assert.equal(turnLevel(-1), 1);
+		assert.equal(turnLevel(NaN), 1);
+	});
+
+	it("isMegaCache: 100% is the boundary", () => {
+		assert.equal(isMegaCache(99.9), false);
+		assert.equal(isMegaCache(100), true);
+		assert.equal(isMegaCache(150), true);
+		assert.equal(isMegaCache(0), false);
+		assert.equal(isMegaCache(NaN), false);
+	});
+
+	it("cacheScore: 0 lookups -> 0 (not NaN), else hits/lookups*100", () => {
+		assert.equal(cacheScore(0, 0), 0);
+		assert.equal(cacheScore(7, 10), 70);
+		assert.equal(cacheScore(0, 5), 0);
+		assert.equal(cacheScore(10, 10), 100);
+		// non-finite inputs are guarded (no NaN leaks)
+		assert.equal(cacheScore(1, NaN), 0);
+		assert.equal(cacheScore(NaN, 5), 0);
+	});
+});
+
+function achRow(value: number, opts: { ts?: number; meta?: unknown } = {}): LeaderboardRow {
+	return { repo_root: "/repo/a", value, ts: opts.ts ?? 1_700_000_000_000, meta: opts.meta ?? null };
+}
+
+describe("evaluateAchievements (S35)", () => {
+	const empty = { dedupe: [] as LeaderboardRow[], turns: [] as LeaderboardRow[], cache: [] as LeaderboardRow[], megaCache: [] as LeaderboardRow[], reposCount: 0 };
+	it("ACHIEVEMENT_DEFS: 9 achievements, exactly 1 hidden", () => {
+		assert.equal(ACHIEVEMENT_DEFS.length, 9);
+		assert.equal(ACHIEVEMENT_DEFS.filter((d) => d.hidden).length, 1);
+	});
+	it("first_compact: >=1 dedupe row", () => {
+		const r = evaluateAchievements({ ...empty, dedupe: [achRow(1)] }, []);
+		assert.ok(r.unlocked.includes("first_compact"));
+		assert.ok(r.newlyUnlocked.includes("first_compact"));
+	});
+	it("compact_streak: max meta.compactCount >= 5", () => {
+		const r = evaluateAchievements({ ...empty, dedupe: [achRow(1, { meta: { compactCount: 5 } })] }, []);
+		assert.ok(r.unlocked.includes("compact_streak"));
+	});
+	it("turn_veteran: max turns >= 25", () => {
+		const r = evaluateAchievements({ ...empty, turns: [achRow(25)] }, []);
+		assert.ok(r.unlocked.includes("turn_veteran"));
+	});
+	it("level_five: turnLevel(maxTurns) >= 5 (15 turns)", () => {
+		const r = evaluateAchievements({ ...empty, turns: [achRow(15)] }, []);
+		assert.ok(r.unlocked.includes("level_five"));
+	});
+	it("dedupe_master: sum dedupe >= 100", () => {
+		const r = evaluateAchievements({ ...empty, dedupe: [achRow(60), achRow(40)] }, []);
+		assert.ok(r.unlocked.includes("dedupe_master"));
+	});
+	it("repo_explorer: reposCount >= 3", () => {
+		const r = evaluateAchievements({ ...empty, reposCount: 3 }, []);
+		assert.ok(r.unlocked.includes("repo_explorer"));
+	});
+	it("night_owl: a row whose local hour is in [0,5)", () => {
+		const d = new Date(); d.setHours(2, 0, 0, 0);
+		const r = evaluateAchievements({ ...empty, cache: [achRow(50, { ts: d.getTime() })] }, []);
+		assert.ok(r.unlocked.includes("night_owl"));
+	});
+	it("flawless: maxCache >= 100 AND no mega_cache overshoot", () => {
+		const r = evaluateAchievements({ ...empty, cache: [achRow(100)], megaCache: [] }, []);
+		assert.ok(r.unlocked.includes("flawless"));
+	});
+	it("flawless NOT when a mega_cache overshoot row (>100) exists", () => {
+		const r = evaluateAchievements({ ...empty, cache: [achRow(100)], megaCache: [achRow(101)] }, []);
+		assert.ok(!r.unlocked.includes("flawless"));
+	});
+	it("opie_wild_ride: any mega_cache trophy row exists", () => {
+		const r = evaluateAchievements({ ...empty, megaCache: [achRow(100)] }, []);
+		assert.ok(r.unlocked.includes("opie_wild_ride"));
+	});
+	it("newlyUnlocked excludes ids already unlocked", () => {
+		const r = evaluateAchievements({ ...empty, dedupe: [achRow(1)] }, ["first_compact"]);
+		assert.ok(r.unlocked.includes("first_compact"));
+		assert.ok(!r.newlyUnlocked.includes("first_compact"));
+	});
+	it("maxCompactCount: 0 when meta absent, else the max", () => {
+		assert.equal(maxCompactCount([achRow(1)]), 0);
+		assert.equal(maxCompactCount([achRow(1, { meta: { compactCount: 7 } })]), 7);
+	});
+});

package/src/game/scoring.ts

@@ -0,0 +1,158 @@
+/**
+ * scoring.ts — pure game-mode scoring helpers (S33) + achievements eval (S35).
+ *
+ * Pi-agnostic: no pi runtime types, no I/O, no dependencies. Every helper is a
+ * pure function so it can be unit-tested in isolation and reused by the
+ * extension event handlers (src/store stays free of pi types too).
+ */
+import type { LeaderboardRow } from "../store/sqlite/game-scores.js";
+
+/** The set of leaderboard metrics tracked in the `game_scores` table. */
+export type GameMetric = "cache" | "dedupe" | "turns" | "repos" | "mega_cache";
+
+/** Canonical allow-list of game metrics (mirrors the schema CHECK constraint). */
+export const METRICS: readonly GameMetric[] = [
+	"cache",
+	"dedupe",
+	"turns",
+	"repos",
+	"mega_cache",
+];
+
+/**
+ * Player level as a function of completed turns.
+ * Sequence: n=0→1, 1→2, 2→2, 3→3, 4→3, 7→4, 15→5, ...
+ * i.e. floor(log2(n+1)) + 1 (one level per doubling of turns). Defensive: any
+ * non-finite / negative input collapses to level 1 (never throws, never NaN).
+ */
+export function turnLevel(n: number): number {
+	if (!Number.isFinite(n) || n < 0) return 1;
+	return Math.floor(Math.log2(n + 1)) + 1;
+}
+
+/**
+ * MEGA CACHE trigger test: the cache hit-rate (real ratio, may exceed 100%)
+ * has crossed the 100% threshold. Used to award the mega_cache trophy + arm
+ * the widget flare (the oopsie gag).
+ */
+export function isMegaCache(pct: number): boolean {
+	return Number.isFinite(pct) && pct >= 100;
+}
+
+/**
+ * Cache-hit percentage (0..100+). Returns 0 when there are no lookups so the
+ * ratio can never be NaN / Infinity (QA3). Safe against non-finite inputs.
+ */
+export function cacheScore(hits: number, lookups: number): number {
+	if (!Number.isFinite(hits) || !Number.isFinite(lookups)) return 0;
+	return lookups > 0 ? (hits / lookups) * 100 : 0;
+}
+
+// ── S35: achievement definitions + evaluation ─────────────────────────────
+
+/** A single achievement definition (the seed row shape, minus unlocked_at). */
+export interface AchievementDef {
+	id: string;
+	title: string;
+	description: string;
+	hidden: boolean;
+	icon: string;
+}
+
+/**
+ * The 9 achievements (8 visible + 1 hidden easter egg = Opie's Wild Ride).
+ * Seeded idempotently into the `game_achievements` table on first open
+ * (schema.ts). Pure, pi-agnostic — no I/O.
+ */
+export const ACHIEVEMENT_DEFS: readonly AchievementDef[] = [
+	{ id: "first_compact", title: "First Compact", description: "Compact a conversation once.", hidden: false, icon: "\u{1F476}" },
+	{ id: "compact_streak", title: "Compact Streak", description: "Compact 5 times in one session.", hidden: false, icon: "\u{1F525}" },
+	{ id: "turn_veteran", title: "Turn Veteran", description: "Reach 25 turns in a repo.", hidden: false, icon: "\u{1F3C3}" },
+	{ id: "level_five", title: "Level 5", description: "Reach player level 5.", hidden: false, icon: "\u{2B50}" },
+	{ id: "dedupe_master", title: "Dedupe Master", description: "Collapse 100 chunks total.", hidden: false, icon: "\u{1F5DC}\u{FE0F}" },
+	{ id: "repo_explorer", title: "Repo Explorer", description: "Use game mode across 3 repos.", hidden: false, icon: "\u{1F30D}" },
+	{ id: "night_owl", title: "Night Owl", description: "Record a score after midnight (00:00–05:00 local).", hidden: false, icon: "\u{1F989}" },
+	{ id: "flawless", title: "Flawless", description: "Hit exactly 100% cache with no overshoot.", hidden: false, icon: "\u{1F4AF}" },
+	{ id: "opie_wild_ride", title: "Opie's Wild Ride", description: "Push the cache past 100%.", hidden: true, icon: "\u{1F3C6}" },
+];
+
+/** Inputs to evaluateAchievements — the S33 leaderboard aggregates. */
+export interface AchievementContext {
+	dedupe: LeaderboardRow[];
+	turns: LeaderboardRow[];
+	cache: LeaderboardRow[];
+	megaCache: LeaderboardRow[];
+	reposCount: number;
+}
+
+/** Result of evaluateAchievements. */
+export interface AchievementEvalResult {
+	unlocked: string[];
+	newlyUnlocked: string[];
+}
+
+/**
+ * Max `compactCount` carried in a dedupe row's `meta` (S33 records
+ * `{ compactCount }` on each session_compact). Returns 0 when absent.
+ */
+export function maxCompactCount(rows: LeaderboardRow[]): number {
+	return rows.reduce((m, r) => {
+		const meta = r.meta;
+		const cm =
+			meta && typeof meta === "object" && "compactCount" in meta
+				? Number((meta as Record<string, unknown>).compactCount) || 0
+				: 0;
+		return Math.max(m, cm);
+	}, 0);
+}
+
+/**
+ * Pure evaluation of the 9 achievements against the leaderboard aggregates.
+ * `alreadyUnlocked` is the set of ids already persisted (so `newlyUnlocked`
+ * excludes them). No I/O, no pi types. Mirrors the S35.9 condition table.
+ */
+export function evaluateAchievements(
+	ctx: AchievementContext,
+	alreadyUnlocked: readonly string[],
+): AchievementEvalResult {
+	const sumBy = (rows: LeaderboardRow[]) =>
+		rows.reduce((s, r) => s + (Number(r.value) || 0), 0);
+	const maxBy = (rows: LeaderboardRow[]) =>
+		rows.reduce((m, r) => Math.max(m, Number(r.value) || 0), 0);
+
+	const dedupeSum = sumBy(ctx.dedupe);
+	const maxTurns = maxBy(ctx.turns);
+	const maxCache = maxBy(ctx.cache);
+	const maxCompact = maxCompactCount(ctx.dedupe);
+
+	// Night owl: any row (across all metrics) recorded between 00:00–05:00 local.
+	const allTs = [
+		...ctx.dedupe,
+		...ctx.turns,
+		...ctx.cache,
+		...ctx.megaCache,
+	];
+	const nightOwl = allTs.some((r) => {
+		const h = new Date(Number(r.ts) || 0).getHours();
+		return h >= 0 && h < 5;
+	});
+
+	// Flawless: cache hit 100%+, but NO mega_cache overshoot (>100).
+	const megaOvershoot = ctx.megaCache.some((r) => Number(r.value) > 100);
+
+	const conditions: Record<string, boolean> = {
+		first_compact: ctx.dedupe.length >= 1,
+		compact_streak: maxCompact >= 5,
+		turn_veteran: maxTurns >= 25,
+		level_five: turnLevel(maxTurns) >= 5,
+		dedupe_master: dedupeSum >= 100,
+		repo_explorer: ctx.reposCount >= 3,
+		night_owl: nightOwl,
+		flawless: maxCache >= 100 && !megaOvershoot,
+		opie_wild_ride: ctx.megaCache.length >= 1,
+	};
+
+	const unlocked = Object.keys(conditions).filter((id) => conditions[id]);
+	const newlyUnlocked = unlocked.filter((id) => !alreadyUnlocked.includes(id));
+	return { unlocked, newlyUnlocked };
+}