Rookery: penguin-themed cubing toolkit, phases 0-1 and GAN BLE

Kotlin Multiplatform + Compose desktop app.

- Sync: per-device append-only op logs (HLC-stamped LWW) in a plain
  folder, safe under Syncthing/Drive; content-addressed image blobs.
- Timer: WCA inspection, +2/DNF, solve table, WCA-correct aoN/moN,
  per-event lifetime PBs with a pixel-penguin party and synthesized
  8-bit chime. Mascot sprite from liz.coffee.
- Scrambles for all WCA events + FTO via tnoodle-lib, with previews.
- Importers: csTimer exports (incl. smart-cube reconstructions and
  cube MACs) and the Letter Pair Gym prototype (words, notes, images,
  history, practice stats). Idempotent; headless `--import`.
- Letter-pair grid with miss heatmap, glance lookup and editor.
- 3D puzzle engine (polyhedron + cut planes) and Canvas renderer:
  NxN 2-7, Pyraminx, Skewb, verified sticker-for-sticker against
  tnoodle; 3D replay of smart-cube solves.
- GAN Gen2/3/4 smart-cube protocol (ported from gan-web-bluetooth,
  MIT) with a BlueZ D-Bus transport and `--cube scan|monitor` CLI.
  Not yet tested against hardware.
- lizCI pipeline (.ci) building a test+package Docker target.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

84 files changed, 12146 insertions, 0 deletions

diff --git a/.ci/.gitignore b/.ci/.gitignore
new file mode 100644
index 0000000..f06235c
--- /dev/null
+++ b/.ci/.gitignore
@@ -0,0 +1,2 @@
+node_modules
+dist
diff --git a/.ci/ci.cjs b/.ci/ci.cjs
new file mode 100755
index 0000000..f7a5dec
--- /dev/null
+++ b/.ci/ci.cjs
@@ -0,0 +1,5047 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/@emprespresso/pengueno/dist/leftpadesque/prepend.js
+var require_prepend = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/leftpadesque/prepend.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.prependWith = void 0;
+    var prependWith = (arr, prep) => Array(arr.length * 2).fill(0).map((_, i) => i % 2 === 0).map((isPrep, i) => isPrep ? prep : arr[Math.floor(i / 2)]);
+    exports2.prependWith = prependWith;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/leftpadesque/debug.js
+var require_debug = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/leftpadesque/debug.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.isDebug = exports2.isProd = void 0;
+    var _hasEnv = true;
+    var _env = _hasEnv && (process.env.ENVIRONMENT ?? "").toLowerCase().includes("prod") ? "production" : "development";
+    var isProd = () => _env === "production";
+    exports2.isProd = isProd;
+    var _debug = !(0, exports2.isProd)() || _hasEnv && ["y", "t"].some((process.env.DEBUG ?? "").toLowerCase().startsWith);
+    var isDebug = () => _debug;
+    exports2.isDebug = isDebug;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/leftpadesque/memoize.js
+var require_memoize = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/leftpadesque/memoize.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.memoize = void 0;
+    var memoize = (fn) => {
+      const cache = /* @__PURE__ */ new Map();
+      return (...args) => {
+        const key = JSON.stringify(args);
+        if (cache.has(key)) {
+          return cache.get(key);
+        }
+        const res = fn(...args);
+        cache.set(key, res);
+        return res;
+      };
+    };
+    exports2.memoize = memoize;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/leftpadesque/index.js
+var require_leftpadesque = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/leftpadesque/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_prepend(), exports2);
+    __exportStar(require_debug(), exports2);
+    __exportStar(require_memoize(), exports2);
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/types/misc.js
+var require_misc = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/types/misc.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/types/object.js
+var require_object = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/types/object.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.isObject = void 0;
+    var isObject3 = (o) => typeof o === "object" && !Array.isArray(o) && !!o;
+    exports2.isObject = isObject3;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/types/tagged.js
+var require_tagged = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/types/tagged.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.isTagged = void 0;
+    var index_1 = require_types();
+    var isTagged = (o, tag) => !!((0, index_1.isObject)(o) && "_tag" in o && o._tag === tag);
+    exports2.isTagged = isTagged;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/types/fn/callable.js
+var require_callable = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/types/fn/callable.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/types/fn/optional.js
+var require_optional = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/types/fn/optional.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.Optional = exports2.IOptionalEmptyError = exports2.isOptional = exports2.IOptionalTag = void 0;
+    var pengueno_1 = require_dist2();
+    exports2.IOptionalTag = "IOptional";
+    var isOptional = (o) => (0, pengueno_1.isTagged)(o, exports2.IOptionalTag);
+    exports2.isOptional = isOptional;
+    var IOptionalEmptyError = class extends Error {
+    };
+    exports2.IOptionalEmptyError = IOptionalEmptyError;
+    var OSomeTag = "O.Some";
+    var ONoneTag = "O.None";
+    var isNone = (o) => (0, pengueno_1.isTagged)(o, ONoneTag);
+    var isSome = (o) => (0, pengueno_1.isTagged)(o, OSomeTag);
+    var _Tagged = class {
+      _tag;
+      constructor(_tag = exports2.IOptionalTag) {
+        this._tag = _tag;
+      }
+    };
+    var Optional = class _Optional extends _Tagged {
+      self;
+      constructor(self) {
+        super();
+        this.self = self;
+      }
+      move(t) {
+        return this.map(() => t);
+      }
+      orSome(supplier) {
+        if (isNone(this.self))
+          return _Optional.from(supplier());
+        return this;
+      }
+      get() {
+        if (isNone(this.self))
+          throw new IOptionalEmptyError("called get() on None optional");
+        return this.self.value;
+      }
+      filter(mapper) {
+        if (isNone(this.self) || !mapper(this.self.value))
+          return _Optional.none();
+        return _Optional.some(this.self.value);
+      }
+      map(mapper) {
+        if (isNone(this.self))
+          return _Optional.none();
+        return _Optional.from(mapper(this.self.value));
+      }
+      flatMap(mapper) {
+        if (isNone(this.self))
+          return _Optional.none();
+        return _Optional.from(mapper(this.self.value)).orSome(() => _Optional.none()).get();
+      }
+      present() {
+        return isSome(this.self);
+      }
+      *[Symbol.iterator]() {
+        if (isSome(this.self))
+          yield this.self.value;
+      }
+      static some(value) {
+        return new _Optional({ value, _tag: OSomeTag });
+      }
+      static _none = new _Optional({ _tag: ONoneTag });
+      static none() {
+        return this._none;
+      }
+      static from(value) {
+        if (value === null || value === void 0)
+          return _Optional.none();
+        return _Optional.some(value);
+      }
+    };
+    exports2.Optional = Optional;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/types/fn/either.js
+var require_either = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/types/fn/either.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.Either = exports2.isRight = exports2.isLeft = exports2.isEither = exports2.IEitherTag = void 0;
+    var pengueno_1 = require_dist2();
+    exports2.IEitherTag = "IEither";
+    var isEither = (o) => (0, pengueno_1.isTagged)(o, exports2.IEitherTag);
+    exports2.isEither = isEither;
+    var ELeftTag = "E.Left";
+    var isLeft = (o) => (0, pengueno_1.isTagged)(o, ELeftTag);
+    exports2.isLeft = isLeft;
+    var ERightTag = "E.Right";
+    var isRight = (o) => (0, pengueno_1.isTagged)(o, ERightTag);
+    exports2.isRight = isRight;
+    var _Tagged = class {
+      _tag;
+      constructor(_tag = exports2.IEitherTag) {
+        this._tag = _tag;
+      }
+    };
+    var Either2 = class _Either extends _Tagged {
+      self;
+      constructor(self) {
+        super();
+        this.self = self;
+      }
+      moveRight(t) {
+        return this.mapRight(() => t);
+      }
+      mapBoth(errBranch, okBranch) {
+        if ((0, exports2.isLeft)(this.self))
+          return _Either.left(errBranch(this.self.err));
+        return _Either.right(okBranch(this.self.ok));
+      }
+      mapRight(mapper) {
+        if ((0, exports2.isRight)(this.self))
+          return _Either.right(mapper(this.self.ok));
+        return _Either.left(this.self.err);
+      }
+      mapLeft(mapper) {
+        if ((0, exports2.isLeft)(this.self))
+          return _Either.left(mapper(this.self.err));
+        return _Either.right(this.self.ok);
+      }
+      flatMap(mapper) {
+        if ((0, exports2.isRight)(this.self))
+          return mapper(this.self.ok);
+        return _Either.left(this.self.err);
+      }
+      filter(mapper) {
+        if ((0, exports2.isLeft)(this.self))
+          return _Either.left(this.self.err);
+        return _Either.fromFailable(() => this.right().filter(mapper).get());
+      }
+      async flatMapAsync(mapper) {
+        if ((0, exports2.isLeft)(this.self))
+          return Promise.resolve(_Either.left(this.self.err));
+        return await mapper(this.self.ok).catch((err) => _Either.left(err));
+      }
+      fold(leftFolder, rightFolder) {
+        if ((0, exports2.isLeft)(this.self))
+          return leftFolder(this.self.err);
+        return rightFolder(this.self.ok);
+      }
+      left() {
+        if ((0, exports2.isLeft)(this.self))
+          return pengueno_1.Optional.from(this.self.err);
+        return pengueno_1.Optional.none();
+      }
+      right() {
+        if ((0, exports2.isRight)(this.self))
+          return pengueno_1.Optional.from(this.self.ok);
+        return pengueno_1.Optional.none();
+      }
+      joinRight(other, mapper) {
+        return this.flatMap((t) => other.mapRight((o) => mapper(o, t)));
+      }
+      joinRightAsync(other, mapper) {
+        return this.flatMapAsync(async (t) => {
+          const o = typeof other === "function" ? other() : other;
+          return await o.then((other2) => other2.mapRight((o2) => mapper(o2, t)));
+        });
+      }
+      swap() {
+        if ((0, exports2.isRight)(this.self))
+          return _Either.left(this.self.ok);
+        return _Either.right(this.self.err);
+      }
+      static left(e) {
+        return new _Either({ err: e, _tag: ELeftTag });
+      }
+      static right(t) {
+        return new _Either({ ok: t, _tag: ERightTag });
+      }
+      static fromFailable(s) {
+        try {
+          return _Either.right(s());
+        } catch (e) {
+          return _Either.left(e);
+        }
+      }
+      static async fromFailableAsync(s) {
+        return await (typeof s === "function" ? s() : s).then((t) => _Either.right(t)).catch((e) => _Either.left(e));
+      }
+      static async retrying(s, attempts = 3, interval = (attempt) => _Either.attemptWait(attempt)) {
+        let result = _Either.right(new Error("No attempts made"));
+        for (let attempt = 0; attempt < attempts && result.right().present(); attempt++) {
+          await interval(attempt);
+          const currentAttempt = await s().then((s2) => s2.swap());
+          result = await result.joinRightAsync(() => Promise.resolve(currentAttempt), (res, _prevError) => res);
+        }
+        return result.swap();
+      }
+      static attemptWait(attempt, backoffFactor = 500, jitter = 300, exponent = 1.3) {
+        if (attempt === 0) {
+          return Promise.resolve();
+        }
+        const wait = Math.pow(exponent, attempt) * backoffFactor + jitter * Math.random() * Math.pow(exponent, attempt);
+        return new Promise((res) => setTimeout(res, wait));
+      }
+    };
+    exports2.Either = Either2;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/types/fn/index.js
+var require_fn = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/types/fn/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_callable(), exports2);
+    __exportStar(require_optional(), exports2);
+    __exportStar(require_either(), exports2);
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/types/collections/cons.js
+var require_cons = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/types/collections/cons.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.ListZipper = exports2.Cons = void 0;
+    var pengueno_1 = require_dist2();
+    var Cons = class _Cons {
+      value;
+      next;
+      constructor(value, next = pengueno_1.Optional.none()) {
+        this.value = value;
+        this.next = next;
+      }
+      before(head) {
+        return new _Cons(this.value, head);
+      }
+      replace(_value) {
+        return new _Cons(_value, this.next);
+      }
+      *[Symbol.iterator]() {
+        for (let cur = pengueno_1.Optional.some(this); cur.present(); cur = cur.flatMap((cur2) => cur2.next)) {
+          yield cur.get().value;
+        }
+      }
+      static addOnto(items, tail) {
+        return Array.from(items).reverse().reduce((cons, value) => pengueno_1.Optional.from(new _Cons(value, cons)), tail);
+      }
+      static from(items) {
+        return _Cons.addOnto(items, pengueno_1.Optional.none());
+      }
+    };
+    exports2.Cons = Cons;
+    var ListZipper = class _ListZipper {
+      reversedPathToHead;
+      currentHead;
+      constructor(reversedPathToHead, currentHead) {
+        this.reversedPathToHead = reversedPathToHead;
+        this.currentHead = currentHead;
+      }
+      read() {
+        return this.currentHead.map(({ value }) => value);
+      }
+      next() {
+        return this.currentHead.map((head) => new _ListZipper(pengueno_1.Optional.some(head.before(this.reversedPathToHead)), head.next));
+      }
+      previous() {
+        return this.reversedPathToHead.map((lastVisited) => new _ListZipper(lastVisited.next, pengueno_1.Optional.some(lastVisited.before(this.currentHead))));
+      }
+      prependChunk(values) {
+        return new _ListZipper(Cons.addOnto(Array.from(values).reverse(), this.reversedPathToHead), this.currentHead);
+      }
+      prepend(value) {
+        return this.prependChunk([value]);
+      }
+      remove() {
+        const newHead = this.currentHead.flatMap((right) => right.next);
+        return new _ListZipper(this.reversedPathToHead, newHead);
+      }
+      replace(value) {
+        const newHead = this.currentHead.map((right) => right.replace(value));
+        return new _ListZipper(this.reversedPathToHead, newHead);
+      }
+      *[Symbol.iterator]() {
+        let head = this;
+        for (let prev = head.previous(); prev.present(); prev = prev.flatMap((p) => p.previous())) {
+          head = prev.get();
+        }
+        if (head.currentHead.present())
+          yield* head.currentHead.get();
+      }
+      collection() {
+        return Array.from(this);
+      }
+      static from(iterable) {
+        return new _ListZipper(pengueno_1.Optional.none(), Cons.from(iterable));
+      }
+    };
+    exports2.ListZipper = ListZipper;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/types/collections/jsonds.js
+var require_jsonds = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/types/collections/jsonds.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.JSONHashMap = exports2.JSONSet = void 0;
+    var JSONSet = class {
+      items;
+      constructor(items = /* @__PURE__ */ new Set()) {
+        this.items = items;
+      }
+      add(item) {
+        const itemJson = JSON.stringify(item, Object.keys(item).sort());
+        this.items.add(itemJson);
+      }
+      has(item) {
+        const itemJson = JSON.stringify(item, Object.keys(item).sort());
+        return this.items.has(itemJson);
+      }
+      delete(item) {
+        const itemJson = JSON.stringify(item, Object.keys(item).sort());
+        return this.items.delete(itemJson);
+      }
+      clear() {
+        this.items.clear();
+      }
+      size() {
+        return this.items.size;
+      }
+    };
+    exports2.JSONSet = JSONSet;
+    var JSONHashMap = class {
+      map;
+      constructor(map = /* @__PURE__ */ new Map()) {
+        this.map = map;
+      }
+      set(key, value) {
+        const keyJson = JSON.stringify(key, Object.keys(key).sort());
+        this.map.set(keyJson, value);
+      }
+      get(key) {
+        const keyJson = JSON.stringify(key, Object.keys(key).sort());
+        return this.map.get(keyJson);
+      }
+      has(key) {
+        const keyJson = JSON.stringify(key, Object.keys(key).sort());
+        return this.map.has(keyJson);
+      }
+      keys() {
+        return Array.from(this.map.keys()).map((x) => JSON.parse(x));
+      }
+      delete(key) {
+        const keyJson = JSON.stringify(key, Object.keys(key).sort());
+        return this.map.delete(keyJson);
+      }
+      clear() {
+        this.map.clear();
+      }
+      size() {
+        return this.map.size;
+      }
+    };
+    exports2.JSONHashMap = JSONHashMap;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/types/collections/index.js
+var require_collections = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/types/collections/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_cons(), exports2);
+    __exportStar(require_jsonds(), exports2);
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/types/index.js
+var require_types = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/types/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_misc(), exports2);
+    __exportStar(require_object(), exports2);
+    __exportStar(require_tagged(), exports2);
+    __exportStar(require_fn(), exports2);
+    __exportStar(require_collections(), exports2);
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/trace/itrace.js
+var require_itrace = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/trace/itrace.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.TraceableImpl = void 0;
+    var TraceableImpl = class _TraceableImpl {
+      item;
+      trace;
+      constructor(item, trace) {
+        this.item = item;
+        this.trace = trace;
+      }
+      map(mapper) {
+        const result = mapper(this);
+        return new _TraceableImpl(result, this.trace);
+      }
+      coExtend(mapper) {
+        const results = mapper(this);
+        return Array.from(results).map((result) => this.move(result));
+      }
+      flatMap(mapper) {
+        return mapper(this);
+      }
+      flatMapAsync(mapper) {
+        return new _TraceableImpl(mapper(this).then((t) => t.get()), this.trace);
+      }
+      traceScope(mapper) {
+        return new _TraceableImpl(this.get(), this.trace.traceScope(mapper(this)));
+      }
+      peek(peek) {
+        peek(this);
+        return this;
+      }
+      move(t) {
+        return this.map(() => t);
+      }
+      bimap(mapper) {
+        const { item, trace: _trace } = mapper(this);
+        return this.move(item).traceScope(() => _trace);
+      }
+      get() {
+        return this.item;
+      }
+    };
+    exports2.TraceableImpl = TraceableImpl;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/trace/metric/emittable.js
+var require_emittable = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/trace/metric/emittable.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.EmittableMetric = void 0;
+    var index_1 = require_metric2();
+    var EmittableMetric = class {
+      name;
+      unit;
+      constructor(name, unit) {
+        this.name = name;
+        this.unit = unit;
+      }
+      withValue(value) {
+        return {
+          name: this.name,
+          unit: this.unit,
+          emissionTimestamp: Date.now(),
+          value,
+          _tag: index_1.MetricValueTag
+        };
+      }
+    };
+    exports2.EmittableMetric = EmittableMetric;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/trace/metric/metric.js
+var require_metric = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/trace/metric/metric.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.ResultMetric = exports2.Metric = void 0;
+    var index_1 = require_metric2();
+    var _Tagged = class {
+      _tag;
+      constructor(_tag = index_1.IMetricTag) {
+        this._tag = _tag;
+      }
+    };
+    var Metric = class _Metric extends _Tagged {
+      name;
+      parent;
+      count;
+      time;
+      static DELIM = ".";
+      constructor(name, parent = void 0, count = new index_1.EmittableMetric(_Metric.join(name, "count"), index_1.Unit.COUNT), time = new index_1.EmittableMetric(_Metric.join(name, "time"), index_1.Unit.MILLISECONDS)) {
+        super();
+        this.name = name;
+        this.parent = parent;
+        this.count = count;
+        this.time = time;
+      }
+      child(_name) {
+        const childName = _Metric.join(this.name, _name);
+        return new _Metric(childName, this);
+      }
+      asResult() {
+        return ResultMetric.from(this);
+      }
+      static join(...name) {
+        return name.join(_Metric.DELIM);
+      }
+      static fromName(name) {
+        return new _Metric(name);
+      }
+    };
+    exports2.Metric = Metric;
+    var ResultMetric = class _ResultMetric extends Metric {
+      name;
+      parent;
+      failure;
+      success;
+      warn;
+      constructor(name, parent = void 0, failure, success, warn) {
+        super(name, parent);
+        this.name = name;
+        this.parent = parent;
+        this.failure = failure;
+        this.success = success;
+        this.warn = warn;
+      }
+      static from(metric) {
+        const failure = metric.child("failure");
+        const success = metric.child("success");
+        const warn = metric.child("warn");
+        return new _ResultMetric(metric.name, metric.parent, failure, success, warn);
+      }
+    };
+    exports2.ResultMetric = ResultMetric;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/trace/metric/trace.js
+var require_trace = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/trace/metric/trace.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.MetricsTrace = exports2.isMetricsTraceSupplier = void 0;
+    var pengueno_1 = require_dist2();
+    var isMetricsTraceSupplier = (t) => (0, pengueno_1.isMetricValue)(t) || (0, pengueno_1.isIMetric)(t) || Array.isArray(t) && t.every((_m) => (0, pengueno_1.isMetricValue)(_m) || (0, pengueno_1.isIMetric)(_m));
+    exports2.isMetricsTraceSupplier = isMetricsTraceSupplier;
+    var MetricsTrace = class _MetricsTrace {
+      metricConsumer;
+      activeTraces;
+      completedTraces;
+      constructor(metricConsumer, activeTraces = /* @__PURE__ */ new Map(), completedTraces = /* @__PURE__ */ new Set()) {
+        this.metricConsumer = metricConsumer;
+        this.activeTraces = activeTraces;
+        this.completedTraces = completedTraces;
+      }
+      traceScope(trace) {
+        const now = Date.now();
+        const metricsToTrace = (Array.isArray(trace) ? trace : [trace]).filter(pengueno_1.isIMetric);
+        const initialTraces = new Map(metricsToTrace.map((metric) => [metric.name, now]));
+        return new _MetricsTrace(this.metricConsumer, initialTraces, this.completedTraces);
+      }
+      trace(metrics) {
+        if (!metrics || typeof metrics === "string") {
+          return this;
+        }
+        const now = Date.now();
+        const allMetrics = Array.isArray(metrics) ? metrics : [metrics];
+        const valuesToEmit = allMetrics.filter(pengueno_1.isMetricValue);
+        const traceableMetrics = allMetrics.filter(pengueno_1.isIMetric);
+        const metricsToStart = traceableMetrics.filter((m) => !this.activeTraces.has(m.name));
+        const metricsToEnd = traceableMetrics.filter((m) => this.activeTraces.has(m.name) && !this.completedTraces.has(m.name));
+        const endedMetricValues = metricsToEnd.flatMap((metric) => [
+          metric.count.withValue(1),
+          metric.time.withValue(now - this.activeTraces.get(metric.name))
+        ]);
+        const parentBasedMetrics = metricsToStart.filter((metric) => {
+          const parent = metric.parent;
+          return parent && this.activeTraces.has(parent.name);
+        });
+        const parentBasedValues = parentBasedMetrics.flatMap((metric) => {
+          const parentStart = this.activeTraces.get(metric.parent.name);
+          return [metric.count.withValue(1), metric.time.withValue(now - parentStart)];
+        });
+        const allMetricsToEmit = [...valuesToEmit, ...endedMetricValues, ...parentBasedValues];
+        if (allMetricsToEmit.length > 0) {
+          this.metricConsumer(allMetricsToEmit);
+        }
+        const nextActiveTraces = new Map([
+          ...this.activeTraces,
+          ...metricsToStart.map((m) => [m.name, now])
+        ]);
+        const nextCompletedTraces = /* @__PURE__ */ new Set([
+          ...this.completedTraces,
+          ...metricsToEnd.map((m) => m.name),
+          ...parentBasedMetrics.map((m) => m.name)
+        ]);
+        return new _MetricsTrace(this.metricConsumer, nextActiveTraces, nextCompletedTraces);
+      }
+    };
+    exports2.MetricsTrace = MetricsTrace;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/trace/metric/index.js
+var require_metric2 = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/trace/metric/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.isIMetric = exports2.IMetricTag = exports2.isMetricValue = exports2.MetricValueTag = exports2.Unit = void 0;
+    var pengueno_1 = require_dist2();
+    var Unit;
+    (function(Unit2) {
+      Unit2["COUNT"] = "COUNT";
+      Unit2["MILLISECONDS"] = "MILLISECONDS";
+    })(Unit || (exports2.Unit = Unit = {}));
+    exports2.MetricValueTag = "MetricValue";
+    var isMetricValue = (t) => (0, pengueno_1.isTagged)(t, exports2.MetricValueTag);
+    exports2.isMetricValue = isMetricValue;
+    exports2.IMetricTag = "IMetric";
+    var isIMetric = (t) => (0, pengueno_1.isTagged)(t, exports2.IMetricTag);
+    exports2.isIMetric = isIMetric;
+    __exportStar(require_emittable(), exports2);
+    __exportStar(require_metric(), exports2);
+    __exportStar(require_trace(), exports2);
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/trace/log/ansi.js
+var require_ansi = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/trace/log/ansi.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.ANSI = void 0;
+    exports2.ANSI = {
+      RESET: "\x1B[0m",
+      BOLD: "\x1B[1m",
+      DIM: "\x1B[2m",
+      RED: "\x1B[31m",
+      GREEN: "\x1B[32m",
+      YELLOW: "\x1B[33m",
+      BLUE: "\x1B[34m",
+      MAGENTA: "\x1B[35m",
+      CYAN: "\x1B[36m",
+      WHITE: "\x1B[37m",
+      BRIGHT_RED: "\x1B[91m",
+      BRIGHT_YELLOW: "\x1B[93m",
+      GRAY: "\x1B[90m"
+    };
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/trace/log/level.js
+var require_level = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/trace/log/level.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.isLogLevel = exports2.logLevelOrder = exports2.LogLevel = void 0;
+    var LogLevel;
+    (function(LogLevel2) {
+      LogLevel2["UNKNOWN"] = "UNKNOWN";
+      LogLevel2["INFO"] = "INFO";
+      LogLevel2["WARN"] = "WARN";
+      LogLevel2["DEBUG"] = "DEBUG";
+      LogLevel2["ERROR"] = "ERROR";
+      LogLevel2["SYS"] = "SYS";
+    })(LogLevel || (exports2.LogLevel = LogLevel = {}));
+    exports2.logLevelOrder = [
+      LogLevel.DEBUG,
+      LogLevel.INFO,
+      LogLevel.WARN,
+      LogLevel.ERROR,
+      LogLevel.SYS
+    ];
+    var isLogLevel = (l) => typeof l === "string" && exports2.logLevelOrder.some((level) => level === l);
+    exports2.isLogLevel = isLogLevel;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/trace/log/logger.js
+var require_logger = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/trace/log/logger.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/trace/log/pretty_json_console.js
+var require_pretty_json_console = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/trace/log/pretty_json_console.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.PrettyJsonConsoleLogger = void 0;
+    var index_1 = require_log();
+    var PrettyJsonConsoleLogger = class {
+      log(level, ...trace) {
+        const message = JSON.stringify({
+          level,
+          trace
+        }, null, 4);
+        const styled = `${this.getStyle(level)}${message}${index_1.ANSI.RESET}
+`;
+        this.getStream(level)(styled);
+      }
+      getStream(level) {
+        if (level === index_1.LogLevel.ERROR) {
+          return console.error;
+        }
+        return console.log;
+      }
+      getStyle(level) {
+        switch (level) {
+          case index_1.LogLevel.UNKNOWN:
+          case index_1.LogLevel.INFO:
+            return `${index_1.ANSI.MAGENTA}`;
+          case index_1.LogLevel.DEBUG:
+            return `${index_1.ANSI.CYAN}`;
+          case index_1.LogLevel.WARN:
+            return `${index_1.ANSI.BRIGHT_YELLOW}`;
+          case index_1.LogLevel.ERROR:
+            return `${index_1.ANSI.BRIGHT_RED}`;
+          case index_1.LogLevel.SYS:
+            return `${index_1.ANSI.DIM}${index_1.ANSI.BLUE}`;
+        }
+      }
+    };
+    exports2.PrettyJsonConsoleLogger = PrettyJsonConsoleLogger;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/trace/log/trace.js
+var require_trace2 = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/trace/log/trace.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.LogTrace = void 0;
+    var pengueno_1 = require_dist2();
+    var index_1 = require_log();
+    var LogTrace = class _LogTrace {
+      logger;
+      traces;
+      defaultLevel;
+      allowedLevels;
+      constructor(logger = new index_1.PrettyJsonConsoleLogger(), traces = [defaultTrace], defaultLevel = index_1.LogLevel.INFO, allowedLevels = defaultAllowedLevelsSupplier) {
+        this.logger = logger;
+        this.traces = traces;
+        this.defaultLevel = defaultLevel;
+        this.allowedLevels = allowedLevels;
+      }
+      traceScope(trace) {
+        return new _LogTrace(this.logger, this.traces.concat(trace), this.defaultLevel, this.allowedLevels);
+      }
+      trace(trace) {
+        const { traces, level: _level } = this.foldTraces(this.traces.concat(trace));
+        if (!this.allowedLevels().has(_level))
+          return;
+        const level = _level === index_1.LogLevel.UNKNOWN ? this.defaultLevel : _level;
+        this.logger.log(level, ...traces);
+      }
+      foldTraces(_traces) {
+        const _logTraces = _traces.map((trace) => typeof trace === "function" ? trace() : trace);
+        const _level = _logTraces.filter((trace) => (0, index_1.isLogLevel)(trace)).reduce((acc, level2) => Math.max(index_1.logLevelOrder.indexOf(level2), acc), -1);
+        const level = index_1.logLevelOrder[_level] ?? index_1.LogLevel.UNKNOWN;
+        const traces = _logTraces.filter((trace) => !(0, index_1.isLogLevel)(trace)).map((trace) => {
+          if (typeof trace === "object") {
+            return `TracedException.Name = ${trace.name}, TracedException.Message = ${trace.message}, TracedException.Stack = ${trace.stack}`;
+          }
+          return trace;
+        });
+        return {
+          level,
+          traces
+        };
+      }
+    };
+    exports2.LogTrace = LogTrace;
+    var defaultTrace = () => `TimeStamp = ${(/* @__PURE__ */ new Date()).toISOString()}`;
+    var defaultAllowedLevels = (0, pengueno_1.memoize)((isDebug) => /* @__PURE__ */ new Set([
+      index_1.LogLevel.UNKNOWN,
+      ...isDebug ? [index_1.LogLevel.DEBUG] : [],
+      index_1.LogLevel.INFO,
+      index_1.LogLevel.WARN,
+      index_1.LogLevel.ERROR,
+      index_1.LogLevel.SYS
+    ]));
+    var defaultAllowedLevelsSupplier = () => defaultAllowedLevels((0, pengueno_1.isDebug)());
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/trace/log/index.js
+var require_log = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/trace/log/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_ansi(), exports2);
+    __exportStar(require_level(), exports2);
+    __exportStar(require_logger(), exports2);
+    __exportStar(require_pretty_json_console(), exports2);
+    __exportStar(require_trace2(), exports2);
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/trace/trace.js
+var require_trace3 = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/trace/trace.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.LogMetricTraceable = exports2.LogMetricTrace = exports2.EmbeddedMetricsTraceable = exports2.LogTraceable = void 0;
+    var _1 = require_trace4();
+    var LogTraceable = class _LogTraceable extends _1.TraceableImpl {
+      static LogTrace = new _1.LogTrace();
+      static of(t) {
+        return new _LogTraceable(t, _LogTraceable.LogTrace);
+      }
+    };
+    exports2.LogTraceable = LogTraceable;
+    var getEmbeddedMetricConsumer = (logTrace) => (metrics) => {
+      if (metrics.length === 0)
+        return;
+      logTrace.traceScope(_1.LogLevel.SYS).trace(`Metrics = <metrics>${JSON.stringify(metrics)}</metrics>`);
+    };
+    var EmbeddedMetricsTraceable = class _EmbeddedMetricsTraceable extends _1.TraceableImpl {
+      static MetricsTrace = new _1.MetricsTrace(getEmbeddedMetricConsumer(LogTraceable.LogTrace));
+      static of(t, metricsTrace = _EmbeddedMetricsTraceable.MetricsTrace) {
+        return new _EmbeddedMetricsTraceable(t, metricsTrace);
+      }
+    };
+    exports2.EmbeddedMetricsTraceable = EmbeddedMetricsTraceable;
+    var LogMetricTrace = class _LogMetricTrace {
+      logTrace;
+      metricsTrace;
+      constructor(logTrace, metricsTrace) {
+        this.logTrace = logTrace;
+        this.metricsTrace = metricsTrace;
+      }
+      traceScope(trace) {
+        if ((0, _1.isMetricsTraceSupplier)(trace)) {
+          return new _LogMetricTrace(this.logTrace, this.metricsTrace.traceScope(trace));
+        }
+        return new _LogMetricTrace(this.logTrace.traceScope(trace), this.metricsTrace);
+      }
+      trace(trace) {
+        if ((0, _1.isMetricsTraceSupplier)(trace)) {
+          this.metricsTrace.trace(trace);
+          return this;
+        }
+        this.logTrace.trace(trace);
+        return this;
+      }
+    };
+    exports2.LogMetricTrace = LogMetricTrace;
+    var LogMetricTraceable = class _LogMetricTraceable extends _1.TraceableImpl {
+      static ofLogTraceable(t) {
+        const metricsTrace = new _1.MetricsTrace(getEmbeddedMetricConsumer(t.trace));
+        return new _LogMetricTraceable(t.get(), new LogMetricTrace(t.trace, metricsTrace));
+      }
+      static of(t) {
+        const logTrace = LogTraceable.of(t);
+        return _LogMetricTraceable.ofLogTraceable(logTrace);
+      }
+    };
+    exports2.LogMetricTraceable = LogMetricTraceable;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/trace/util.js
+var require_util = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/trace/util.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.TraceUtil = void 0;
+    var pengueno_1 = require_dist2();
+    var TraceUtil = class _TraceUtil {
+      static promiseify(mapper) {
+        return (traceablePromise) => traceablePromise.flatMapAsync(async (t) => t.move(await t.get()).map(mapper)).get();
+      }
+      static traceResultingEither(metric, warnOnFailure = false) {
+        return (t) => {
+          if (metric)
+            t.trace.trace(t.get().fold((_err) => warnOnFailure ? metric.warn : metric.failure, (_ok) => metric.success));
+          return t.traceScope((_t) => _t.get().fold((_err) => warnOnFailure ? pengueno_1.LogLevel.WARN : pengueno_1.LogLevel.ERROR, (_ok) => pengueno_1.LogLevel.INFO));
+        };
+      }
+      static withTrace(trace) {
+        return (t) => t.traceScope(() => trace);
+      }
+      static withMetricTrace(metric) {
+        return _TraceUtil.withTrace(metric);
+      }
+      static withFunctionTrace(f) {
+        return _TraceUtil.withTrace(`fn.${f.name}`);
+      }
+      static withClassTrace(c) {
+        return _TraceUtil.withTrace(`class.${c.constructor.name}`);
+      }
+    };
+    exports2.TraceUtil = TraceUtil;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/trace/index.js
+var require_trace4 = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/trace/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_itrace(), exports2);
+    __exportStar(require_metric2(), exports2);
+    __exportStar(require_log(), exports2);
+    __exportStar(require_trace3(), exports2);
+    __exportStar(require_util(), exports2);
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/process/exec.js
+var require_exec = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/process/exec.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.getStdoutMany = exports2.getStdout = exports2.CmdMetric = void 0;
+    var pengueno_1 = require_dist2();
+    var node_child_process_1 = require("node:child_process");
+    exports2.CmdMetric = pengueno_1.Metric.fromName("Exec").asResult();
+    var getStdout = (cmd, options = { streamTraceable: [] }) => cmd.flatMap(pengueno_1.TraceUtil.withFunctionTrace(exports2.getStdout)).flatMap((tCmd) => tCmd.traceScope(() => `Command = ${tCmd.get()}`)).map((tCmd) => {
+      const cmd2 = tCmd.get();
+      const _exec = typeof cmd2 === "string" ? cmd2 : cmd2.join(" ");
+      const env = options.clearEnv ? options.env : { ...process.env, ...options.env };
+      return pengueno_1.Either.fromFailableAsync(new Promise((res, rej) => {
+        const proc = (0, node_child_process_1.exec)(_exec, { env });
+        let stdout = "";
+        proc.stdout?.on("data", (d) => {
+          const s = d.toString();
+          stdout += s;
+          if (options.streamTraceable?.includes("stdout")) {
+            tCmd.trace.trace(s);
+          }
+        });
+        const stderr = "";
+        proc.stderr?.on("data", (d) => {
+          const s = d.toString();
+          stdout += s;
+          if (options.streamTraceable?.includes("stderr")) {
+            tCmd.trace.trace(s);
+          }
+        });
+        proc.on("exit", (code) => {
+          const streams = { stdout, stderr };
+          if (code === 0) {
+            res(streams);
+          } else {
+            rej(new Error(`exited with non-zero code: ${code}. ${stderr}`));
+          }
+        });
+      }));
+    }).map(pengueno_1.TraceUtil.promiseify((tEitherStdStreams) => tEitherStdStreams.get().mapRight(({ stderr, stdout }) => {
+      if (stderr)
+        tEitherStdStreams.trace.traceScope(pengueno_1.LogLevel.DEBUG).trace(`StdErr = ${stderr}`);
+      return stdout;
+    }))).peek(pengueno_1.TraceUtil.promiseify(pengueno_1.TraceUtil.traceResultingEither(exports2.CmdMetric))).get();
+    exports2.getStdout = getStdout;
+    var getStdoutMany = (cmds, options = { streamTraceable: [] }) => cmds.coExtend((t) => t.get()).reduce(async (_result, tCmd) => {
+      const result = await _result;
+      return result.joinRightAsync(() => tCmd.map((cmd) => (0, exports2.getStdout)(cmd, options)).get(), (stdout, pre) => pre.concat(stdout));
+    }, Promise.resolve(pengueno_1.Either.right([])));
+    exports2.getStdoutMany = getStdoutMany;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/process/env.js
+var require_env = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/process/env.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.getRequiredEnvVars = exports2.getRequiredEnv = exports2.getEnv = void 0;
+    var pengueno_1 = require_dist2();
+    var getEnv = (name) => pengueno_1.Optional.from(process.env[name]);
+    exports2.getEnv = getEnv;
+    var getRequiredEnv = (name) => pengueno_1.Either.fromFailable(() => (0, exports2.getEnv)(name).get()).mapLeft(() => new Error(`environment variable "${name}" is required D:`));
+    exports2.getRequiredEnv = getRequiredEnv;
+    var getRequiredEnvVars = (vars) => {
+      const emptyEnvironment = pengueno_1.Either.right({});
+      const addTo = (env, key, val) => ({
+        ...env,
+        [key]: val
+      });
+      return vars.reduce((environment, key) => environment.joinRight((0, exports2.getRequiredEnv)(key), (value, environment2) => addTo(environment2, key, value)), emptyEnvironment);
+    };
+    exports2.getRequiredEnvVars = getRequiredEnvVars;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/process/validate_identifier.js
+var require_validate_identifier = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/process/validate_identifier.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.validateExecutionEntries = exports2.validateIdentifier = void 0;
+    var pengueno_1 = require_dist2();
+    var validateIdentifier = (token) => {
+      return /^[a-zA-Z0-9_\?\&\=\-:. \/]+$/.test(token) && !token.includes("..");
+    };
+    exports2.validateIdentifier = validateIdentifier;
+    var validateExecutionEntries = (obj) => {
+      const invalidEntries = Object.entries(obj).filter((e) => !e.every((x) => typeof x === "string" && (0, exports2.validateIdentifier)(x)));
+      if (invalidEntries.length > 0)
+        return pengueno_1.Either.left(invalidEntries);
+      return pengueno_1.Either.right(obj);
+    };
+    exports2.validateExecutionEntries = validateExecutionEntries;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/process/argv.js
+var require_argv = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/process/argv.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.argv = exports2.getArg = exports2.isArgKey = void 0;
+    var pengueno_1 = require_dist2();
+    var isArgKey = (k) => k.startsWith("--");
+    exports2.isArgKey = isArgKey;
+    var getArg = (arg, argv2, whenValue) => {
+      const argIndex = pengueno_1.Optional.from(argv2.findIndex((_argv) => (0, exports2.isArgKey)(_argv) && _argv.split("=")[0] === arg)).filter((index) => index >= 0 && index < argv2.length);
+      if (!argIndex.present()) {
+        return pengueno_1.Optional.from(whenValue.absent).map((v) => pengueno_1.Either.right(v)).orSome(() => pengueno_1.Either.left(new Error(`arg ${arg} is not present in arguments list and does not have an 'absent' value`))).get();
+      }
+      return argIndex.flatMap((idx) => pengueno_1.Optional.from(argv2.at(idx)).map((_argv) => _argv.includes("=") ? _argv.split("=")[1] : argv2.at(idx + 1))).filter((next) => !(0, exports2.isArgKey)(next)).map((next) => whenValue.present(next)).orSome(() => whenValue.unspecified).map((v) => pengueno_1.Either.right(v)).get();
+    };
+    exports2.getArg = getArg;
+    var argv = (args, handlers, argv2 = process.argv.slice(2)) => {
+      const defaultHandler = { present: (value) => value };
+      const processArg = (arg) => {
+        const handler = handlers?.[arg] ?? defaultHandler;
+        return (0, exports2.getArg)(arg, argv2, handler).mapRight((value) => [arg, value]);
+      };
+      const res = args.map(processArg).reduce((acc, current) => acc.flatMap((accValue) => current.mapRight(([key, value]) => ({
+        ...accValue,
+        [key]: value
+      }))), pengueno_1.Either.right({})).mapRight((result) => result);
+      return res;
+    };
+    exports2.argv = argv;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/process/signals.js
+var require_signals = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/process/signals.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.Signals = exports2.SigTermMetric = exports2.SigIntMetric = void 0;
+    var pengueno_1 = require_dist2();
+    exports2.SigIntMetric = pengueno_1.Metric.fromName("SigInt").asResult();
+    exports2.SigTermMetric = pengueno_1.Metric.fromName("SigTerm").asResult();
+    var Signals = class {
+      static async awaitClose(t) {
+        const success = pengueno_1.Either.right(void 0);
+        return new Promise((res) => {
+          const metricizedInterruptHandler = (metric) => (err) => t.flatMap(pengueno_1.TraceUtil.withMetricTrace(metric)).peek((_t) => _t.trace.trace("closing")).move(pengueno_1.Optional.from(err).map((e) => pengueno_1.Either.left(e)).orSome(() => success).get()).flatMap(pengueno_1.TraceUtil.traceResultingEither(metric)).map((e) => res(e.get())).peek((_t) => _t.trace.trace("finished")).get();
+          const sigintCloser = metricizedInterruptHandler(exports2.SigIntMetric);
+          const sigtermCloser = metricizedInterruptHandler(exports2.SigTermMetric);
+          process.on("SIGINT", () => t.flatMap(pengueno_1.TraceUtil.withTrace("SIGINT")).get().close(sigintCloser));
+          process.on("SIGTERM", () => t.flatMap(pengueno_1.TraceUtil.withTrace("SIGTERM")).get().close(sigtermCloser));
+        });
+      }
+    };
+    exports2.Signals = Signals;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/process/index.js
+var require_process = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/process/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_exec(), exports2);
+    __exportStar(require_env(), exports2);
+    __exportStar(require_validate_identifier(), exports2);
+    __exportStar(require_argv(), exports2);
+    __exportStar(require_signals(), exports2);
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/server/http/body.js
+var require_body = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/server/http/body.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/server/http/status.js
+var require_status = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/server/http/status.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.HttpStatusCodes = void 0;
+    exports2.HttpStatusCodes = {
+      100: "Continue",
+      101: "Switching Protocols",
+      102: "Processing (WebDAV)",
+      200: "OK",
+      201: "Created",
+      202: "Accepted",
+      203: "Non-Authoritative Information",
+      204: "No Content",
+      205: "Reset Content",
+      206: "Partial Content",
+      207: "Multi-Status (WebDAV)",
+      208: "Already Reported (WebDAV)",
+      226: "IM Used",
+      300: "Multiple Choices",
+      301: "Moved Permanently",
+      302: "Found",
+      303: "See Other",
+      304: "Not Modified",
+      305: "Use Proxy",
+      306: "(Unused)",
+      307: "Temporary Redirect",
+      308: "Permanent Redirect (experimental)",
+      400: "Bad Request",
+      401: "Unauthorized",
+      402: "Payment Required",
+      403: "Forbidden",
+      404: "Not Found",
+      405: "Method Not Allowed",
+      406: "Not Acceptable",
+      407: "Proxy Authentication Required",
+      408: "Request Timeout",
+      409: "Conflict",
+      410: "Gone",
+      411: "Length Required",
+      412: "Precondition Failed",
+      413: "Request Entity Too Large",
+      414: "Request-URI Too Long",
+      415: "Unsupported Media Type",
+      416: "Requested Range Not Satisfiable",
+      417: "Expectation Failed",
+      418: "I'm a teapot (RFC 2324)",
+      420: "Enhance Your Calm (Twitter)",
+      422: "Unprocessable Entity (WebDAV)",
+      423: "Locked (WebDAV)",
+      424: "Failed Dependency (WebDAV)",
+      425: "Reserved for WebDAV",
+      426: "Upgrade Required",
+      428: "Precondition Required",
+      429: "Too Many Requests",
+      431: "Request Header Fields Too Large",
+      444: "No Response (Nginx)",
+      449: "Retry With (Microsoft)",
+      450: "Blocked by Windows Parental Controls (Microsoft)",
+      451: "Unavailable For Legal Reasons",
+      499: "Client Closed Request (Nginx)",
+      500: "Internal Server Error",
+      501: "Not Implemented",
+      502: "Bad Gateway",
+      503: "Service Unavailable",
+      504: "Gateway Timeout",
+      505: "HTTP Version Not Supported",
+      506: "Variant Also Negotiates (Experimental)",
+      507: "Insufficient Storage (WebDAV)",
+      508: "Loop Detected (WebDAV)",
+      509: "Bandwidth Limit Exceeded (Apache)",
+      510: "Not Extended",
+      511: "Network Authentication Required",
+      598: "Network read timeout error",
+      599: "Network connect timeout error"
+    };
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/server/http/method.js
+var require_method = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/server/http/method.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/server/http/index.js
+var require_http = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/server/http/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_body(), exports2);
+    __exportStar(require_status(), exports2);
+    __exportStar(require_method(), exports2);
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/server/response/pengueno.js
+var require_pengueno = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/server/response/pengueno.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.JsonResponse = exports2.PenguenoResponse = exports2.getResponseMetrics = void 0;
+    var pengueno_1 = require_dist2();
+    var getHeaders = (req, extraHeaders) => {
+      const optHeaders = {
+        ...req.getResponseHeaders(),
+        ...extraHeaders
+      };
+      optHeaders["Content-Type"] = (optHeaders["Content-Type"] ?? "text/plain") + "; charset=utf-8";
+      return optHeaders;
+    };
+    var ResponseCodeMetrics = [0, 1, 2, 3, 4, 5].map((x) => pengueno_1.Metric.fromName(`response.${x}xx`).asResult());
+    var getResponseMetrics = (status, elapsedMs) => {
+      const index = Math.floor(status / 100);
+      return ResponseCodeMetrics.flatMap((metric, i) => pengueno_1.Optional.from(i).filter((i2) => i2 === index).map(() => [metric.count.withValue(1)]).flatMap((metricValues) => pengueno_1.Optional.from(elapsedMs).map((ms) => metricValues.concat(metric.time.withValue(ms))).orSome(() => metricValues)).orSome(() => [metric.count.withValue(0)]).get());
+    };
+    exports2.getResponseMetrics = getResponseMetrics;
+    var PenguenoResponse = class {
+      _body;
+      statusText;
+      status;
+      headers;
+      constructor(req, _body, opts) {
+        this._body = _body;
+        this.headers = getHeaders(req.get(), opts?.headers ?? {});
+        this.status = opts.status;
+        this.statusText = opts.statusText ?? pengueno_1.HttpStatusCodes[this.status];
+        req.trace.trace((0, exports2.getResponseMetrics)(opts.status, req.get().elapsedTimeMs()));
+      }
+      body() {
+        return this._body;
+      }
+    };
+    exports2.PenguenoResponse = PenguenoResponse;
+    var JsonResponse = class extends PenguenoResponse {
+      constructor(req, e, _opts) {
+        const opts = { ..._opts, headers: { ..._opts.headers, "Content-Type": "application/json" } };
+        if ((0, pengueno_1.isEither)(e)) {
+          super(req, JSON.stringify(e.fold((error) => ({ error, ok: void 0 }), (ok) => ({ ok }))), opts);
+          return;
+        }
+        super(req, JSON.stringify(Math.floor(opts.status / 100) > 4 ? { error: e } : { ok: e }), opts);
+      }
+    };
+    exports2.JsonResponse = JsonResponse;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/server/response/index.js
+var require_response = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/server/response/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_pengueno(), exports2);
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/server/request/pengueno.js
+var require_pengueno2 = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/server/request/pengueno.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.PenguenoRequest = void 0;
+    var greetings = ["hewwo :D", "hiya cutie", "boop!", "sending virtual hugs!", "stay pawsitive"];
+    var penguenoGreeting = () => greetings[Math.floor(Math.random() * greetings.length)];
+    var PenguenoRequest = class _PenguenoRequest {
+      req;
+      id;
+      at;
+      constructor(req, id, at) {
+        this.req = req;
+        this.id = id;
+        this.at = at;
+      }
+      elapsedTimeMs(after = () => Date.now()) {
+        return after() - this.at.getTime();
+      }
+      getResponseHeaders() {
+        const RequestId = this.id;
+        const RequestReceivedUnix = this.at.getTime();
+        const RequestHandleUnix = Date.now();
+        const DeltaUnix = this.elapsedTimeMs(() => RequestHandleUnix);
+        const Hai = penguenoGreeting();
+        return Object.entries({
+          RequestId,
+          RequestReceivedUnix,
+          RequestHandleUnix,
+          DeltaUnix,
+          Hai
+        }).reduce((acc, [key, val]) => ({ ...acc, [key]: val.toString() }), {});
+      }
+      static from(request) {
+        const id = crypto.randomUUID();
+        return request.bimap((tRequest) => {
+          const request2 = tRequest.get();
+          const url = new URL(request2.url);
+          const { pathname } = url;
+          const trace = `RequestId = ${id}, Method = ${request2.method}, Path = ${pathname}`;
+          return { item: new _PenguenoRequest(request2, id, /* @__PURE__ */ new Date()), trace };
+        });
+      }
+    };
+    exports2.PenguenoRequest = PenguenoRequest;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/server/request/index.js
+var require_request = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/server/request/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_pengueno2(), exports2);
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/server/activity/health.js
+var require_health = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/server/activity/health.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.HealthCheckActivityImpl = exports2.HealthCheckOutput = exports2.HealthCheckInput = void 0;
+    var pengueno_1 = require_dist2();
+    var HealthCheckInput;
+    (function(HealthCheckInput2) {
+      HealthCheckInput2[HealthCheckInput2["CHECK"] = 0] = "CHECK";
+    })(HealthCheckInput || (exports2.HealthCheckInput = HealthCheckInput = {}));
+    var HealthCheckOutput;
+    (function(HealthCheckOutput2) {
+      HealthCheckOutput2[HealthCheckOutput2["YAASSSLAYQUEEN"] = 0] = "YAASSSLAYQUEEN";
+    })(HealthCheckOutput || (exports2.HealthCheckOutput = HealthCheckOutput = {}));
+    var healthCheckMetric = pengueno_1.Metric.fromName("Health").asResult();
+    var HealthCheckActivityImpl = class {
+      check;
+      constructor(check) {
+        this.check = check;
+      }
+      checkHealth(req) {
+        return req.flatMap(pengueno_1.TraceUtil.withFunctionTrace(this.checkHealth)).flatMap(pengueno_1.TraceUtil.withMetricTrace(healthCheckMetric)).flatMap((r) => r.move(HealthCheckInput.CHECK).map((input) => this.check(input))).peek(pengueno_1.TraceUtil.promiseify(pengueno_1.TraceUtil.traceResultingEither(healthCheckMetric))).map(pengueno_1.TraceUtil.promiseify((h) => {
+          const { status, message } = h.get().fold(() => ({ status: 500, message: "err" }), () => ({ status: 200, message: "ok" }));
+          return new pengueno_1.JsonResponse(req, message, { status });
+        })).get();
+      }
+    };
+    exports2.HealthCheckActivityImpl = HealthCheckActivityImpl;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/server/activity/fourohfour.js
+var require_fourohfour = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/server/activity/fourohfour.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.FourOhFourActivityImpl = void 0;
+    var pengueno_1 = require_dist2();
+    var messages = [
+      "D: meow-t found! your api call ran away!",
+      "404-bidden! but like...in a cute way >:3 !",
+      ":< your data went on a paw-sible vacation!",
+      "uwu~ not found, but found our hearts instead!"
+    ];
+    var randomFourOhFour = () => messages[Math.floor(Math.random() * messages.length)];
+    var FourOhFourActivityImpl = class {
+      fourOhFour(req) {
+        return req.move(new pengueno_1.JsonResponse(req, randomFourOhFour(), { status: 404 })).map((resp) => Promise.resolve(resp.get())).get();
+      }
+    };
+    exports2.FourOhFourActivityImpl = FourOhFourActivityImpl;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/server/activity/index.js
+var require_activity = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/server/activity/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_health(), exports2);
+    __exportStar(require_fourohfour(), exports2);
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/server/filter/method.js
+var require_method2 = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/server/filter/method.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.requireMethod = void 0;
+    var pengueno_1 = require_dist2();
+    var requireMethod = (methods) => (req) => req.flatMap(pengueno_1.TraceUtil.withFunctionTrace(exports2.requireMethod)).map((t) => {
+      const { req: { method } } = t.get();
+      if (!methods.includes(method)) {
+        const msg = "that's not how you pet me (\u22DF\uFE4F\u22DE)~";
+        t.trace.traceScope(pengueno_1.LogLevel.WARN).trace(msg);
+        return pengueno_1.Either.left(new pengueno_1.PenguenoError(msg, 405));
+      }
+      return pengueno_1.Either.right(method);
+    }).get();
+    exports2.requireMethod = requireMethod;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/server/filter/json.js
+var require_json = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/server/filter/json.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.jsonModel = void 0;
+    var pengueno_1 = require_dist2();
+    var ParseJsonMetric = pengueno_1.Metric.fromName("JsonParse").asResult();
+    var jsonModel = (jsonTransformer) => (r) => r.flatMap(pengueno_1.TraceUtil.withFunctionTrace(exports2.jsonModel)).flatMap(pengueno_1.TraceUtil.withMetricTrace(ParseJsonMetric)).map((j) => pengueno_1.Either.fromFailableAsync(j.get().req.json()).then((either) => either.mapLeft((errReason) => {
+      j.trace.traceScope(pengueno_1.LogLevel.WARN).trace(errReason);
+      return new pengueno_1.PenguenoError("seems to be invalid JSON (>//<) can you fix?", 400);
+    }))).flatMapAsync(pengueno_1.TraceUtil.promiseify(pengueno_1.TraceUtil.traceResultingEither(ParseJsonMetric))).map(pengueno_1.TraceUtil.promiseify((traceableEitherJson) => traceableEitherJson.get().mapRight((j) => traceableEitherJson.move(j)).flatMap(jsonTransformer))).get();
+    exports2.jsonModel = jsonModel;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/server/filter/index.js
+var require_filter = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/server/filter/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.PenguenoError = exports2.ErrorSource = void 0;
+    var pengueno_1 = require_dist2();
+    var ErrorSource;
+    (function(ErrorSource2) {
+      ErrorSource2["USER"] = "WARN";
+      ErrorSource2["SYSTEM"] = "ERROR";
+    })(ErrorSource || (exports2.ErrorSource = ErrorSource = {}));
+    var PenguenoError = class extends Error {
+      message;
+      status;
+      source;
+      constructor(message, status) {
+        super(message);
+        this.message = message;
+        this.status = status;
+        this.source = Math.floor(status / 100) === 4 ? ErrorSource.USER : ErrorSource.SYSTEM;
+      }
+    };
+    exports2.PenguenoError = PenguenoError;
+    __exportStar(require_method2(), exports2);
+    __exportStar(require_json(), exports2);
+  }
+});
+
+// node_modules/hono/dist/cjs/http-exception.js
+var require_http_exception = __commonJS({
+  "node_modules/hono/dist/cjs/http-exception.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var HTTPException = class extends Error {
+      res;
+      status;
+      /**
+      * Creates an instance of `HTTPException`.
+      * @param status - HTTP status code for the exception. Defaults to 500.
+      * @param options - Additional options for the exception.
+      */
+      constructor(status = 500, options) {
+        super(options?.message, { cause: options?.cause });
+        this.res = options?.res;
+        this.status = status;
+      }
+      /**
+      * Returns the response object associated with the exception.
+      * If a response object is not provided, a new response is created with the error message and status code.
+      * @returns The response object.
+      */
+      getResponse() {
+        if (this.res) return new Response(this.res.body, {
+          status: this.status,
+          headers: this.res.headers
+        });
+        return new Response(this.message, { status: this.status });
+      }
+    };
+    exports2.HTTPException = HTTPException;
+  }
+});
+
+// node_modules/hono/dist/cjs/request/constants.js
+var require_constants = __commonJS({
+  "node_modules/hono/dist/cjs/request/constants.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var GET_MATCH_RESULT = Symbol();
+    exports2.GET_MATCH_RESULT = GET_MATCH_RESULT;
+  }
+});
+
+// node_modules/hono/dist/cjs/utils/crypto.js
+var require_crypto = __commonJS({
+  "node_modules/hono/dist/cjs/utils/crypto.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var sha256 = async (data) => {
+      return await createHash(data, {
+        name: "SHA-256",
+        alias: "sha256"
+      });
+    };
+    var sha1 = async (data) => {
+      return await createHash(data, {
+        name: "SHA-1",
+        alias: "sha1"
+      });
+    };
+    var md5 = async (data) => {
+      return await createHash(data, {
+        name: "MD5",
+        alias: "md5"
+      });
+    };
+    var createHash = async (data, algorithm) => {
+      let sourceBuffer;
+      if (ArrayBuffer.isView(data) || data instanceof ArrayBuffer) sourceBuffer = data;
+      else {
+        if (typeof data === "object") data = JSON.stringify(data);
+        sourceBuffer = new TextEncoder().encode(String(data));
+      }
+      if (crypto && crypto.subtle) {
+        const buffer = await crypto.subtle.digest({ name: algorithm.name }, sourceBuffer);
+        return Array.prototype.map.call(new Uint8Array(buffer), (x) => ("00" + x.toString(16)).slice(-2)).join("");
+      }
+      return null;
+    };
+    exports2.createHash = createHash;
+    exports2.md5 = md5;
+    exports2.sha1 = sha1;
+    exports2.sha256 = sha256;
+  }
+});
+
+// node_modules/hono/dist/cjs/utils/buffer.js
+var require_buffer = __commonJS({
+  "node_modules/hono/dist/cjs/utils/buffer.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_utils_crypto = require_crypto();
+    var equal = (a, b) => {
+      if (a === b) return true;
+      if (a.byteLength !== b.byteLength) return false;
+      const va = new DataView(a);
+      const vb = new DataView(b);
+      let i = va.byteLength;
+      while (i--) if (va.getUint8(i) !== vb.getUint8(i)) return false;
+      return true;
+    };
+    var constantTimeEqualString = (a, b) => {
+      const aLen = a.length;
+      const bLen = b.length;
+      const maxLen = Math.max(aLen, bLen);
+      let out = aLen ^ bLen;
+      for (let i = 0; i < maxLen; i++) {
+        const aChar = i < aLen ? a.charCodeAt(i) : 0;
+        const bChar = i < bLen ? b.charCodeAt(i) : 0;
+        out |= aChar ^ bChar;
+      }
+      return out === 0;
+    };
+    var timingSafeEqualString = async (a, b, hashFunction) => {
+      if (!hashFunction) hashFunction = require_utils_crypto.sha256;
+      const [sa, sb] = await Promise.all([hashFunction(a), hashFunction(b)]);
+      if (sa == null || sb == null || typeof sa !== "string" || typeof sb !== "string") return false;
+      const hashEqual = constantTimeEqualString(sa, sb);
+      const originalEqual = constantTimeEqualString(a, b);
+      return hashEqual && originalEqual;
+    };
+    var timingSafeEqual = async (a, b, hashFunction) => {
+      if (typeof a === "string" && typeof b === "string") return timingSafeEqualString(a, b, hashFunction);
+      if (!hashFunction) hashFunction = require_utils_crypto.sha256;
+      const [sa, sb] = await Promise.all([hashFunction(a), hashFunction(b)]);
+      if (!sa || !sb || typeof sa !== "string" || typeof sb !== "string") return false;
+      return timingSafeEqualString(sa, sb);
+    };
+    var bufferToString = (buffer) => {
+      if (buffer instanceof ArrayBuffer) return new TextDecoder("utf-8").decode(buffer);
+      return buffer;
+    };
+    var bufferToFormData = (arrayBuffer, contentType) => {
+      return new Response(arrayBuffer, { headers: { "Content-Type": contentType.replace(/^[^;]+/, (mediaType) => mediaType.toLowerCase()) } }).formData();
+    };
+    exports2.bufferToFormData = bufferToFormData;
+    exports2.bufferToString = bufferToString;
+    exports2.equal = equal;
+    exports2.timingSafeEqual = timingSafeEqual;
+  }
+});
+
+// node_modules/hono/dist/cjs/utils/body.js
+var require_body2 = __commonJS({
+  "node_modules/hono/dist/cjs/utils/body.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_utils_buffer = require_buffer();
+    var MAX_NESTED_OBJECTS = 1e4;
+    var isRawRequest = (request) => "headers" in request;
+    var parseBody = async (request, options = /* @__PURE__ */ Object.create(null)) => {
+      const { all = false, dot = false } = options;
+      const mediaType = (isRawRequest(request) ? request.headers : request.raw.headers).get("Content-Type")?.split(";")[0].trim().toLowerCase();
+      if (mediaType === "multipart/form-data" || mediaType === "application/x-www-form-urlencoded") return parseFormData(request, {
+        all,
+        dot
+      });
+      return {};
+    };
+    async function parseFormData(request, options) {
+      if (!isRawRequest(request) && request.bodyCache.formData) return convertFormDataToBodyData(await request.bodyCache.formData, options);
+      const headers = isRawRequest(request) ? request.headers : request.raw.headers;
+      const arrayBuffer = await request.arrayBuffer();
+      const formDataPromise = require_utils_buffer.bufferToFormData(arrayBuffer, headers.get("Content-Type") || "");
+      if (!isRawRequest(request)) request.bodyCache.formData = formDataPromise;
+      const formData = await formDataPromise;
+      if (formData) return convertFormDataToBodyData(formData, options);
+      return {};
+    }
+    function convertFormDataToBodyData(formData, options) {
+      const form = /* @__PURE__ */ Object.create(null);
+      const nestingState = { count: 0 };
+      formData.forEach((value, key) => {
+        if (!(options.all || key.endsWith("[]"))) form[key] = value;
+        else handleParsingAllValues(form, key, value);
+      });
+      if (options.dot) Object.entries(form).forEach(([key, value]) => {
+        if (key.includes(".")) {
+          handleParsingNestedValues(form, key, value, nestingState);
+          delete form[key];
+        }
+      });
+      return form;
+    }
+    var handleParsingAllValues = (form, key, value) => {
+      if (form[key] !== void 0) {
+        if (Array.isArray(form[key])) form[key].push(value);
+        else form[key] = [form[key], value];
+      } else if (!key.endsWith("[]")) form[key] = value;
+      else form[key] = [value];
+    };
+    var handleParsingNestedValues = (form, key, value, state) => {
+      if (/(?:^|\.)__proto__\./.test(key)) return;
+      let nestedForm = form;
+      const keys = key.split(".", 34);
+      if (keys.length > 33) throwNestingLimitExceeded();
+      keys.forEach((key2, index) => {
+        if (index === keys.length - 1) nestedForm[key2] = value;
+        else {
+          if (!nestedForm[key2] || typeof nestedForm[key2] !== "object" || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) {
+            if (state.count++ >= MAX_NESTED_OBJECTS) throwNestingLimitExceeded();
+            nestedForm[key2] = /* @__PURE__ */ Object.create(null);
+          }
+          nestedForm = nestedForm[key2];
+        }
+      });
+    };
+    var throwNestingLimitExceeded = () => {
+      throw new Error("Nesting limit exceeded");
+    };
+    exports2.parseBody = parseBody;
+  }
+});
+
+// node_modules/hono/dist/cjs/utils/url.js
+var require_url = __commonJS({
+  "node_modules/hono/dist/cjs/utils/url.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var splitPath = (path) => {
+      const paths = path.split("/");
+      if (paths[0] === "") paths.shift();
+      return paths;
+    };
+    var splitRoutingPath = (routePath) => {
+      const { groups, path } = extractGroupsFromPath(routePath);
+      const paths = splitPath(path);
+      return replaceGroupMarks(paths, groups);
+    };
+    var extractGroupsFromPath = (path) => {
+      const groups = [];
+      path = path.replace(/\{[^}]+\}/g, (match, index) => {
+        const mark = `@${index}`;
+        groups.push([mark, match]);
+        return mark;
+      });
+      return {
+        groups,
+        path
+      };
+    };
+    var replaceGroupMarks = (paths, groups) => {
+      for (let i = groups.length - 1; i >= 0; i--) {
+        const [mark] = groups[i];
+        for (let j = paths.length - 1; j >= 0; j--) if (paths[j].includes(mark)) {
+          paths[j] = paths[j].replace(mark, groups[i][1]);
+          break;
+        }
+      }
+      return paths;
+    };
+    var patternCache = {};
+    var getPattern = (label, next) => {
+      if (label === "*") return "*";
+      const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+      if (match) {
+        const cacheKey = `${label}#${next}`;
+        if (!patternCache[cacheKey]) {
+          if (match[2]) patternCache[cacheKey] = next && next[0] !== ":" && next[0] !== "*" ? [
+            cacheKey,
+            match[1],
+            new RegExp(`^${match[2]}(?=/${next})`)
+          ] : [
+            label,
+            match[1],
+            new RegExp(`^${match[2]}$`)
+          ];
+          else patternCache[cacheKey] = [
+            label,
+            match[1],
+            true
+          ];
+        }
+        return patternCache[cacheKey];
+      }
+      return null;
+    };
+    var tryDecode = (str, decoder) => {
+      try {
+        return decoder(str);
+      } catch {
+        return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
+          try {
+            return decoder(match);
+          } catch {
+            return match;
+          }
+        });
+      }
+    };
+    var tryDecodeURI = (str) => tryDecode(str, decodeURI);
+    var decodeURIWithPreservedPercent = (value) => decodeURI(value.includes("%25") ? value.replace(/%25/g, "%2525") : value);
+    var getPath = (request) => {
+      const url = request.url;
+      const start = url.indexOf("/", url.indexOf(":") + 4);
+      let i = start;
+      for (; i < url.length; i++) {
+        const charCode = url.charCodeAt(i);
+        if (charCode === 37) {
+          const queryIndex = url.indexOf("?", i);
+          const hashIndex = url.indexOf("#", i);
+          const end = queryIndex === -1 ? hashIndex === -1 ? void 0 : hashIndex : hashIndex === -1 ? queryIndex : Math.min(queryIndex, hashIndex);
+          const path = url.slice(start, end);
+          const decoded = tryDecode(path, decodeURIWithPreservedPercent);
+          if (/%(?![0-9A-Fa-f]{2})/.test(path)) {
+            const rewritten = new URL("http://localhost");
+            rewritten.pathname = decoded.replace(/[\\\t\n\r]/g, encodeURIComponent);
+            if (tryDecode(rewritten.pathname, decodeURIWithPreservedPercent) !== decoded) return tryDecode(path.replace(/%(?![0-9A-Fa-f]{2})/g, "%25"), decodeURIWithPreservedPercent);
+          }
+          return decoded;
+        } else if (charCode === 63 || charCode === 35) break;
+      }
+      return url.slice(start, i);
+    };
+    var getQueryStrings = (url) => {
+      const queryIndex = url.indexOf("?", 8);
+      if (queryIndex === -1) return "";
+      const hashIndex = url.indexOf("#", 8);
+      return hashIndex === -1 ? url.slice(queryIndex) : queryIndex < hashIndex ? url.slice(queryIndex, hashIndex) : "";
+    };
+    var getPathNoStrict = (request) => {
+      const result = getPath(request);
+      return result.length > 1 && result.at(-1) === "/" ? result.slice(0, -1) : result;
+    };
+    var mergePath = (base, sub, ...rest) => {
+      if (rest.length) sub = mergePath(sub, ...rest);
+      return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
+    };
+    var checkOptionalParameter = (path) => {
+      if (path.charCodeAt(path.length - 1) !== 63 || !path.includes(":")) return null;
+      const segments = path.split("/");
+      const results = [];
+      let basePath = "";
+      segments.forEach((segment) => {
+        if (segment !== "" && !/\:/.test(segment)) basePath += "/" + segment;
+        else if (/\:/.test(segment)) {
+          if (segment.charCodeAt(segment.length - 1) === 63) {
+            if (results.length === 0 && basePath === "") results.push("/");
+            else results.push(basePath);
+            const optionalSegment = segment.slice(0, -1);
+            basePath += "/" + optionalSegment;
+            results.push(basePath);
+          } else basePath += "/" + segment;
+        }
+      });
+      return results.filter((v, i, a) => a.indexOf(v) === i);
+    };
+    var tryDecodeURIComponent = (str) => str.indexOf("%") !== -1 ? tryDecode(str, decodeURIComponent_) : str;
+    var _decodeURI = (value) => {
+      if (value.indexOf("+") !== -1) value = value.replace(/\+/g, " ");
+      return tryDecodeURIComponent(value);
+    };
+    var _getQueryParam = (url, key, multiple) => {
+      const hashIndex = url.indexOf("#", 8);
+      if (hashIndex !== -1) url = url.slice(0, hashIndex);
+      let encoded;
+      if (!multiple && key && !/[%+&=]/.test(key)) {
+        const queryIndex = url.indexOf("?", 8);
+        let keyIndex2 = queryIndex;
+        if (keyIndex2 === -1) return;
+        if (!url.startsWith(key, keyIndex2 + 1)) keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
+        while (keyIndex2 !== -1) {
+          const trailingKeyCode = url.charCodeAt(keyIndex2 + key.length + 1);
+          if (trailingKeyCode === 61 || trailingKeyCode === 38 || isNaN(trailingKeyCode)) {
+            if (keyIndex2 > queryIndex && /(?:^|&)[^=&]*[%+]/.test(url.slice(queryIndex + 1, keyIndex2))) break;
+            if (trailingKeyCode === 61) {
+              const valueIndex = keyIndex2 + key.length + 2;
+              const endIndex = url.indexOf("&", valueIndex);
+              return _decodeURI(url.slice(valueIndex, endIndex === -1 ? void 0 : endIndex));
+            }
+            return "";
+          }
+          keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
+        }
+        encoded = /[%+]/.test(url);
+        if (!encoded) return;
+      }
+      const results = /* @__PURE__ */ Object.create(null);
+      encoded ??= /[%+]/.test(url);
+      let keyIndex = url.indexOf("?", 8);
+      while (keyIndex !== -1) {
+        const nextKeyIndex = url.indexOf("&", keyIndex + 1);
+        let valueIndex = url.indexOf("=", keyIndex);
+        if (valueIndex > nextKeyIndex && nextKeyIndex !== -1) valueIndex = -1;
+        let name = url.slice(keyIndex + 1, valueIndex === -1 ? nextKeyIndex === -1 ? void 0 : nextKeyIndex : valueIndex);
+        if (encoded) name = _decodeURI(name);
+        keyIndex = nextKeyIndex;
+        if (name === "") continue;
+        let value;
+        if (valueIndex === -1) value = "";
+        else {
+          value = url.slice(valueIndex + 1, nextKeyIndex === -1 ? void 0 : nextKeyIndex);
+          if (encoded) value = _decodeURI(value);
+        }
+        if (multiple) {
+          if (!(results[name] && Array.isArray(results[name]))) results[name] = [];
+          results[name].push(value);
+        } else results[name] ??= value;
+      }
+      return key ? results[key] : results;
+    };
+    var getQueryParam = _getQueryParam;
+    var getQueryParams = (url, key) => {
+      return _getQueryParam(url, key, true);
+    };
+    var decodeURIComponent_ = decodeURIComponent;
+    exports2.checkOptionalParameter = checkOptionalParameter;
+    exports2.decodeURIComponent_ = decodeURIComponent_;
+    exports2.getPath = getPath;
+    exports2.getPathNoStrict = getPathNoStrict;
+    exports2.getPattern = getPattern;
+    exports2.getQueryParam = getQueryParam;
+    exports2.getQueryParams = getQueryParams;
+    exports2.getQueryStrings = getQueryStrings;
+    exports2.mergePath = mergePath;
+    exports2.splitPath = splitPath;
+    exports2.splitRoutingPath = splitRoutingPath;
+    exports2.tryDecode = tryDecode;
+    exports2.tryDecodeURI = tryDecodeURI;
+    exports2.tryDecodeURIComponent = tryDecodeURIComponent;
+  }
+});
+
+// node_modules/hono/dist/cjs/request.js
+var require_request2 = __commonJS({
+  "node_modules/hono/dist/cjs/request.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_http_exception2 = require_http_exception();
+    var require_request_constants = require_constants();
+    var require_utils_body = require_body2();
+    var require_utils_url = require_url();
+    var HonoRequest = class {
+      /**
+      * `.raw` can get the raw Request object.
+      *
+      * @see {@link https://hono.dev/docs/api/request#raw}
+      *
+      * @example
+      * ```ts
+      * // For Cloudflare Workers
+      * app.post('/', async (c) => {
+      *   const metadata = c.req.raw.cf?.hostMetadata?
+      *   ...
+      * })
+      * ```
+      */
+      raw;
+      #validatedData;
+      #matchResult;
+      routeIndex = 0;
+      /**
+      * `.path` can get the pathname of the request.
+      *
+      * @see {@link https://hono.dev/docs/api/request#path}
+      *
+      * @example
+      * ```ts
+      * app.get('/about/me', (c) => {
+      *   const pathname = c.req.path // `/about/me`
+      * })
+      * ```
+      */
+      path;
+      bodyCache = {};
+      constructor(request, path = "/", matchResult = [[]]) {
+        this.raw = request;
+        this.path = path;
+        this.#matchResult = matchResult;
+      }
+      param(key) {
+        return key ? this.#getDecodedParam(key) : this.#getAllDecodedParams();
+      }
+      #getDecodedParam(key) {
+        const paramKey = this.#matchResult[0][this.routeIndex]?.[1][key];
+        const param = this.#getParamValue(paramKey);
+        return param && require_utils_url.tryDecodeURIComponent(param);
+      }
+      #getAllDecodedParams() {
+        const decoded = {};
+        const keys = Object.keys(this.#matchResult[0][this.routeIndex]?.[1] ?? {});
+        for (const key of keys) {
+          const value = this.#getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
+          if (value !== void 0) decoded[key] = require_utils_url.tryDecodeURIComponent(value);
+        }
+        return decoded;
+      }
+      #getParamValue(paramKey) {
+        return this.#matchResult[1] ? this.#matchResult[1][paramKey] : paramKey;
+      }
+      query(key) {
+        return require_utils_url.getQueryParam(this.url, key);
+      }
+      queries(key) {
+        return require_utils_url.getQueryParams(this.url, key);
+      }
+      header(name) {
+        if (name) return this.raw.headers.get(name) ?? void 0;
+        const headerData = /* @__PURE__ */ Object.create(null);
+        this.raw.headers.forEach((value, key) => {
+          headerData[key] = value;
+        });
+        return headerData;
+      }
+      async parseBody(options) {
+        return require_utils_body.parseBody(this, options);
+      }
+      #cachedBody = (key) => {
+        const { bodyCache, raw } = this;
+        const cachedBody = bodyCache[key];
+        if (cachedBody) return cachedBody;
+        for (const anyCachedKey in bodyCache) return bodyCache[anyCachedKey].then((body) => {
+          if (anyCachedKey === "json") body = JSON.stringify(body);
+          const contentType = anyCachedKey === "formData" ? void 0 : raw.headers.get("content-type");
+          return new Response(body, { headers: contentType ? { "Content-Type": contentType } : void 0 })[key]();
+        });
+        return bodyCache[key] = raw[key]();
+      };
+      /**
+      * `.json()` can parse Request body of type `application/json`
+      *
+      * @see {@link https://hono.dev/docs/api/request#json}
+      *
+      * @example
+      * ```ts
+      * app.post('/entry', async (c) => {
+      *   const body = await c.req.json()
+      * })
+      * ```
+      */
+      json() {
+        return this.#cachedBody("text").then((text) => JSON.parse(text));
+      }
+      /**
+      * `.text()` can parse Request body of type `text/plain`
+      *
+      * @see {@link https://hono.dev/docs/api/request#text}
+      *
+      * @example
+      * ```ts
+      * app.post('/entry', async (c) => {
+      *   const body = await c.req.text()
+      * })
+      * ```
+      */
+      text() {
+        return this.#cachedBody("text");
+      }
+      /**
+      * `.arrayBuffer()` parse Request body as an `ArrayBuffer`
+      *
+      * @see {@link https://hono.dev/docs/api/request#arraybuffer}
+      *
+      * @example
+      * ```ts
+      * app.post('/entry', async (c) => {
+      *   const body = await c.req.arrayBuffer()
+      * })
+      * ```
+      */
+      arrayBuffer() {
+        return this.#cachedBody("arrayBuffer");
+      }
+      /**
+      * `.bytes()` parses the request body as a `Uint8Array`.
+      *
+      * @see {@link https://hono.dev/docs/api/request#bytes}
+      *
+      * @example
+      * ```ts
+      * app.post('/entry', async (c) => {
+      *   const body = await c.req.bytes()
+      * })
+      * ```
+      */
+      bytes() {
+        return this.#cachedBody("arrayBuffer").then((buffer) => new Uint8Array(buffer));
+      }
+      /**
+      * Parses the request body as a `Blob`.
+      * @example
+      * ```ts
+      * app.post('/entry', async (c) => {
+      *   const body = await c.req.blob();
+      * });
+      * ```
+      * @see https://hono.dev/docs/api/request#blob
+      */
+      blob() {
+        return this.#cachedBody("blob");
+      }
+      /**
+      * Parses the request body as `FormData`.
+      * @example
+      * ```ts
+      * app.post('/entry', async (c) => {
+      *   const body = await c.req.formData();
+      * });
+      * ```
+      * @see https://hono.dev/docs/api/request#formdata
+      */
+      formData() {
+        return this.#cachedBody("formData");
+      }
+      /**
+      * Adds validated data to the request.
+      *
+      * @param target - The target of the validation.
+      * @param data - The validated data to add.
+      */
+      addValidatedData(target, data) {
+        (this.#validatedData ??= {})[target] = data;
+      }
+      valid(target) {
+        return this.#validatedData?.[target];
+      }
+      /**
+      * `.url` can get the request url strings.
+      *
+      * @see {@link https://hono.dev/docs/api/request#url}
+      *
+      * @example
+      * ```ts
+      * app.get('/about/me', (c) => {
+      *   const url = c.req.url // `http://localhost:8787/about/me`
+      *   ...
+      * })
+      * ```
+      */
+      get url() {
+        return this.raw.url;
+      }
+      /**
+      * `.method` can get the method name of the request.
+      *
+      * @see {@link https://hono.dev/docs/api/request#method}
+      *
+      * @example
+      * ```ts
+      * app.get('/about/me', (c) => {
+      *   const method = c.req.method // `GET`
+      * })
+      * ```
+      */
+      get method() {
+        return this.raw.method;
+      }
+      get [require_request_constants.GET_MATCH_RESULT]() {
+        return this.#matchResult;
+      }
+      /**
+      * `.matchedRoutes` can return a matched route in the handler
+      *
+      * @deprecated
+      *
+      * Use matchedRoutes helper defined in "hono/route" instead.
+      *
+      * @see {@link https://hono.dev/docs/api/request#matchedroutes}
+      *
+      * @example
+      * ```ts
+      * app.use('*', async function logger(c, next) {
+      *   await next()
+      *   c.req.matchedRoutes.forEach(({ handler, method, path }, i) => {
+      *     const name = handler.name || (handler.length < 2 ? '[handler]' : '[middleware]')
+      *     console.log(
+      *       method,
+      *       ' ',
+      *       path,
+      *       ' '.repeat(Math.max(10 - path.length, 0)),
+      *       name,
+      *       i === c.req.routeIndex ? '<- respond from here' : ''
+      *     )
+      *   })
+      * })
+      * ```
+      */
+      get matchedRoutes() {
+        return this.#matchResult[0].map(([[, route]]) => route);
+      }
+      /**
+      * `.routePath` can retrieve the path registered within the handler
+      *
+      * @deprecated
+      *
+      * Use routePath helper defined in "hono/route" instead.
+      *
+      * @see {@link https://hono.dev/docs/api/request#routepath}
+      *
+      * @example
+      * ```ts
+      * app.get('/posts/:id', (c) => {
+      *   return c.json({ path: c.req.routePath })
+      * })
+      * ```
+      */
+      get routePath() {
+        return this.#matchResult[0].map(([[, route]]) => route)[this.routeIndex].path;
+      }
+    };
+    var cloneRawRequest = async (req) => {
+      if (!req.raw.bodyUsed) return req.raw.clone();
+      const cacheKey = Object.keys(req.bodyCache)[0];
+      if (!cacheKey) throw new require_http_exception2.HTTPException(500, { message: "Cannot clone request: body was already consumed and not cached. Please use HonoRequest methods (e.g., req.json(), req.text()) instead of consuming req.raw directly." });
+      let body = await req[cacheKey]();
+      const headers = req.header();
+      if (cacheKey === "json") {
+        body = JSON.stringify(body);
+        delete headers["content-length"];
+      } else if (body instanceof FormData) {
+        delete headers["content-type"];
+        delete headers["content-length"];
+      }
+      const requestInit = {
+        body,
+        cache: req.raw.cache,
+        credentials: req.raw.credentials,
+        headers,
+        integrity: req.raw.integrity,
+        keepalive: req.raw.keepalive,
+        method: req.method,
+        mode: req.raw.mode,
+        redirect: req.raw.redirect,
+        referrer: req.raw.referrer,
+        referrerPolicy: req.raw.referrerPolicy,
+        signal: req.raw.signal
+      };
+      return new Request(req.url, requestInit);
+    };
+    exports2.HonoRequest = HonoRequest;
+    exports2.cloneRawRequest = cloneRawRequest;
+  }
+});
+
+// node_modules/hono/dist/cjs/utils/html.js
+var require_html = __commonJS({
+  "node_modules/hono/dist/cjs/utils/html.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var HtmlEscapedCallbackPhase = {
+      Stringify: 1,
+      BeforeStream: 2,
+      Stream: 3
+    };
+    var raw = (value, callbacks) => {
+      const escapedString = new String(value);
+      escapedString.isEscaped = true;
+      escapedString.callbacks = callbacks;
+      return escapedString;
+    };
+    var escapeRe = /[&<>'"]/;
+    var stringBufferToString = async (buffer, callbacks) => {
+      let str = "";
+      callbacks ||= [];
+      const resolvedBuffer = await Promise.all(buffer);
+      for (let i = resolvedBuffer.length - 1; ; i--) {
+        str += resolvedBuffer[i];
+        i--;
+        if (i < 0) break;
+        let r = resolvedBuffer[i];
+        if (typeof r === "object") callbacks.push(...r.callbacks || []);
+        const isEscaped = r.isEscaped;
+        r = await (typeof r === "object" ? r.toString() : r);
+        if (typeof r === "object") callbacks.push(...r.callbacks || []);
+        if (r.isEscaped ?? isEscaped) str += r;
+        else {
+          const buf = [str];
+          escapeToBuffer(r, buf);
+          str = buf[0];
+        }
+      }
+      return raw(str, callbacks);
+    };
+    var escapeToBuffer = (str, buffer) => {
+      const match = str.search(escapeRe);
+      if (match === -1) {
+        buffer[0] += str;
+        return;
+      }
+      let escape;
+      let index;
+      let lastIndex = 0;
+      for (index = match; index < str.length; index++) {
+        switch (str.charCodeAt(index)) {
+          case 34:
+            escape = "&quot;";
+            break;
+          case 39:
+            escape = "&#39;";
+            break;
+          case 38:
+            escape = "&amp;";
+            break;
+          case 60:
+            escape = "&lt;";
+            break;
+          case 62:
+            escape = "&gt;";
+            break;
+          default:
+            continue;
+        }
+        buffer[0] += str.substring(lastIndex, index) + escape;
+        lastIndex = index + 1;
+      }
+      buffer[0] += str.substring(lastIndex, index);
+    };
+    var resolveCallbackSync = (str) => {
+      const callbacks = str.callbacks;
+      if (!callbacks?.length) return str;
+      const buffer = [str];
+      const context = {};
+      callbacks.forEach((c) => c({
+        phase: HtmlEscapedCallbackPhase.Stringify,
+        buffer,
+        context
+      }));
+      return buffer[0];
+    };
+    var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) => {
+      if (typeof str === "object" && !(str instanceof String)) {
+        if (!(str instanceof Promise)) str = str.toString();
+        if (str instanceof Promise) str = await str;
+      }
+      const callbacks = str.callbacks;
+      if (!callbacks?.length) return Promise.resolve(str);
+      if (buffer) buffer[0] += str;
+      else buffer = [str];
+      const resStr = Promise.all(callbacks.map((c) => c({
+        phase,
+        buffer,
+        context
+      }))).then((res) => Promise.all(res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer))).then(() => buffer[0]));
+      if (preserveCallbacks) return raw(await resStr, callbacks);
+      else return resStr;
+    };
+    exports2.HtmlEscapedCallbackPhase = HtmlEscapedCallbackPhase;
+    exports2.escapeToBuffer = escapeToBuffer;
+    exports2.raw = raw;
+    exports2.resolveCallback = resolveCallback;
+    exports2.resolveCallbackSync = resolveCallbackSync;
+    exports2.stringBufferToString = stringBufferToString;
+  }
+});
+
+// node_modules/hono/dist/cjs/context.js
+var require_context = __commonJS({
+  "node_modules/hono/dist/cjs/context.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_request3 = require_request2();
+    var require_utils_html = require_html();
+    var TEXT_PLAIN = "text/plain; charset=UTF-8";
+    var setDefaultContentType = (contentType, headers) => {
+      return {
+        "Content-Type": contentType,
+        ...headers
+      };
+    };
+    var createResponseInstance = (body, init) => new Response(body, init);
+    var Context = class {
+      #rawRequest;
+      #req;
+      /**
+      * `.env` can get bindings (environment variables, secrets, KV namespaces, D1 database, R2 bucket etc.) in Cloudflare Workers.
+      *
+      * @see {@link https://hono.dev/docs/api/context#env}
+      *
+      * @example
+      * ```ts
+      * // Environment object for Cloudflare Workers
+      * app.get('*', async c => {
+      *   const counter = c.env.COUNTER
+      * })
+      * ```
+      */
+      env = {};
+      #var;
+      finalized = false;
+      /**
+      * `.error` can get the error object from the middleware if the Handler throws an error.
+      *
+      * @see {@link https://hono.dev/docs/api/context#error}
+      *
+      * @example
+      * ```ts
+      * app.use('*', async (c, next) => {
+      *   await next()
+      *   if (c.error) {
+      *     // do something...
+      *   }
+      * })
+      * ```
+      */
+      error;
+      #status;
+      #executionCtx;
+      #res;
+      #layout;
+      #renderer;
+      #notFoundHandler;
+      #preparedHeaders;
+      #matchResult;
+      #path;
+      /**
+      * Creates an instance of the Context class.
+      *
+      * @param req - The Request object.
+      * @param options - Optional configuration options for the context.
+      */
+      constructor(req, options) {
+        this.#rawRequest = req;
+        if (options) {
+          this.#executionCtx = options.executionCtx;
+          this.env = options.env;
+          this.#notFoundHandler = options.notFoundHandler;
+          this.#path = options.path;
+          this.#matchResult = options.matchResult;
+        }
+      }
+      /**
+      * `.req` is the instance of {@link HonoRequest}.
+      */
+      get req() {
+        this.#req ??= new require_request3.HonoRequest(this.#rawRequest, this.#path, this.#matchResult);
+        return this.#req;
+      }
+      /**
+      * @see {@link https://hono.dev/docs/api/context#event}
+      * The FetchEvent associated with the current request.
+      *
+      * @throws Will throw an error if the context does not have a FetchEvent.
+      */
+      get event() {
+        if (this.#executionCtx && "respondWith" in this.#executionCtx) return this.#executionCtx;
+        else throw Error("This context has no FetchEvent");
+      }
+      /**
+      * @see {@link https://hono.dev/docs/api/context#executionctx}
+      * The ExecutionContext associated with the current request.
+      *
+      * @throws Will throw an error if the context does not have an ExecutionContext.
+      */
+      get executionCtx() {
+        if (this.#executionCtx) return this.#executionCtx;
+        else throw Error("This context has no ExecutionContext");
+      }
+      /**
+      * @see {@link https://hono.dev/docs/api/context#res}
+      * The Response object for the current request.
+      */
+      get res() {
+        return this.#res ||= createResponseInstance(null, { headers: this.#preparedHeaders ??= new Headers() });
+      }
+      /**
+      * Sets the Response object for the current request.
+      *
+      * @param _res - The Response object to set.
+      */
+      set res(_res) {
+        if (this.#res && _res) {
+          _res = createResponseInstance(_res.body, _res);
+          for (const [k, v] of this.#res.headers.entries()) {
+            if (k === "content-type") continue;
+            if (k === "set-cookie") {
+              const cookies = this.#res.headers.getSetCookie();
+              _res.headers.delete("set-cookie");
+              for (const cookie of cookies) _res.headers.append("set-cookie", cookie);
+            } else _res.headers.set(k, v);
+          }
+        }
+        this.#res = _res;
+        this.finalized = true;
+      }
+      /**
+      * `.render()` can create a response within a layout.
+      *
+      * @see {@link https://hono.dev/docs/api/context#render-setrenderer}
+      *
+      * @example
+      * ```ts
+      * app.get('/', (c) => {
+      *   return c.render('Hello!')
+      * })
+      * ```
+      */
+      render = (...args) => {
+        this.#renderer ??= (content) => this.html(content);
+        return this.#renderer(...args);
+      };
+      /**
+      * Sets the layout for the response.
+      *
+      * @param layout - The layout to set.
+      * @returns The layout function.
+      */
+      setLayout = (layout) => this.#layout = layout;
+      /**
+      * Gets the current layout for the response.
+      *
+      * @returns The current layout function.
+      */
+      getLayout = () => this.#layout;
+      /**
+      * `.setRenderer()` can set the layout in the custom middleware.
+      *
+      * @see {@link https://hono.dev/docs/api/context#render-setrenderer}
+      *
+      * @example
+      * ```tsx
+      * app.use('*', async (c, next) => {
+      *   c.setRenderer((content) => {
+      *     return c.html(
+      *       <html>
+      *         <body>
+      *           <p>{content}</p>
+      *         </body>
+      *       </html>
+      *     )
+      *   })
+      *   await next()
+      * })
+      * ```
+      */
+      setRenderer = (renderer) => {
+        this.#renderer = renderer;
+      };
+      /**
+      * `.header()` can set headers.
+      *
+      * @see {@link https://hono.dev/docs/api/context#header}
+      *
+      * @example
+      * ```ts
+      * app.get('/welcome', (c) => {
+      *   // Set headers
+      *   c.header('X-Message', 'Hello!')
+      *   c.header('Content-Type', 'text/plain')
+      *
+      *   // Append multiple headers using the append option (e.g. Vary)
+      *   c.header('Vary', 'Accept-Encoding', { append: true })
+      *   c.header('Vary', 'User-Agent', { append: true })
+      *
+      *   return c.body('Thank you for coming')
+      * })
+      * ```
+      */
+      header = (name, value, options) => {
+        if (this.finalized && !this.#res.bodyUsed) this.#res = createResponseInstance(this.#res.body, this.#res);
+        const headers = this.#res ? this.#res.headers : this.#preparedHeaders ??= new Headers();
+        if (value === void 0) headers.delete(name);
+        else if (options?.append) headers.append(name, value);
+        else headers.set(name, value);
+      };
+      status = (status) => {
+        this.#status = status;
+      };
+      /**
+      * `.set()` can set the value specified by the key.
+      *
+      * @see {@link https://hono.dev/docs/api/context#set-get}
+      *
+      * @example
+      * ```ts
+      * app.use('*', async (c, next) => {
+      *   c.set('message', 'Hono is hot!!')
+      *   await next()
+      * })
+      * ```
+      */
+      set = (key, value) => {
+        this.#var ??= /* @__PURE__ */ new Map();
+        this.#var.set(key, value);
+      };
+      /**
+      * `.get()` can use the value specified by the key.
+      *
+      * @see {@link https://hono.dev/docs/api/context#set-get}
+      *
+      * @example
+      * ```ts
+      * app.get('/', (c) => {
+      *   const message = c.get('message')
+      *   return c.text(`The message is "${message}"`)
+      * })
+      * ```
+      */
+      get = (key) => {
+        return this.#var ? this.#var.get(key) : void 0;
+      };
+      /**
+      * `.var` can access the value of a variable.
+      *
+      * @see {@link https://hono.dev/docs/api/context#var}
+      *
+      * @example
+      * ```ts
+      * const result = c.var.client.oneMethod()
+      * ```
+      */
+      get var() {
+        if (!this.#var) return {};
+        return Object.fromEntries(this.#var);
+      }
+      #newResponse(data, arg, headers) {
+        let responseHeaders = this.#res ? new Headers(this.#res.headers) : this.#preparedHeaders;
+        if (typeof arg === "object" && arg.headers) {
+          responseHeaders ??= new Headers();
+          for (const [key, value] of new Headers(arg.headers)) if (key === "set-cookie") responseHeaders.append(key, value);
+          else responseHeaders.set(key, value);
+        }
+        if (headers) {
+          if (!responseHeaders) {
+            let count = 0;
+            for (const k in headers) if (++count > 1 || typeof headers[k] !== "string") {
+              responseHeaders = new Headers();
+              break;
+            }
+          }
+          if (responseHeaders) for (const k in headers) {
+            const v = headers[k];
+            if (typeof v === "string") responseHeaders.set(k, v);
+            else {
+              responseHeaders.delete(k);
+              for (const v2 of v) responseHeaders.append(k, v2);
+            }
+          }
+        }
+        const status = typeof arg === "number" ? arg : arg?.status ?? this.#status;
+        return createResponseInstance(data, {
+          status,
+          headers: responseHeaders ?? headers
+        });
+      }
+      newResponse = (...args) => this.#newResponse(...args);
+      /**
+      * `.body()` can return the HTTP response.
+      * You can set headers with `.header()` and set HTTP status code with `.status`.
+      * This can also be set in `.text()`, `.json()` and so on.
+      *
+      * @see {@link https://hono.dev/docs/api/context#body}
+      *
+      * @example
+      * ```ts
+      * app.get('/welcome', (c) => {
+      *   // Set headers
+      *   c.header('X-Message', 'Hello!')
+      *   c.header('Content-Type', 'text/plain')
+      *   // Set HTTP status code
+      *   c.status(201)
+      *
+      *   // Return the response body
+      *   return c.body('Thank you for coming')
+      * })
+      * ```
+      */
+      body = (data, arg, headers) => this.#newResponse(data, arg, headers);
+      /**
+      * `.text()` can render text as `Content-Type:text/plain`.
+      *
+      * @see {@link https://hono.dev/docs/api/context#text}
+      *
+      * @example
+      * ```ts
+      * app.get('/say', (c) => {
+      *   return c.text('Hello!')
+      * })
+      * ```
+      */
+      text = (text, arg, headers) => {
+        return !this.#preparedHeaders && !this.#status && !arg && !headers && !this.finalized ? new Response(text) : this.#newResponse(text, arg, setDefaultContentType(TEXT_PLAIN, headers));
+      };
+      /**
+      * `.json()` can render JSON as `Content-Type:application/json`.
+      *
+      * @see {@link https://hono.dev/docs/api/context#json}
+      *
+      * @example
+      * ```ts
+      * app.get('/api', (c) => {
+      *   return c.json({ message: 'Hello!' })
+      * })
+      * ```
+      */
+      json = (object, arg, headers) => {
+        return this.#newResponse(JSON.stringify(object), arg, setDefaultContentType("application/json", headers));
+      };
+      html = (html, arg, headers) => {
+        const res = (html2) => this.#newResponse(html2, arg, setDefaultContentType("text/html; charset=UTF-8", headers));
+        return typeof html === "object" ? require_utils_html.resolveCallback(html, require_utils_html.HtmlEscapedCallbackPhase.Stringify, false, {}).then(res) : res(html);
+      };
+      /**
+      * `.redirect()` can Redirect, default status code is 302.
+      *
+      * @see {@link https://hono.dev/docs/api/context#redirect}
+      *
+      * @example
+      * ```ts
+      * app.get('/redirect', (c) => {
+      *   return c.redirect('/')
+      * })
+      * app.get('/redirect-permanently', (c) => {
+      *   return c.redirect('/', 301)
+      * })
+      * ```
+      */
+      redirect = (location, status) => {
+        const locationString = String(location);
+        this.header("Location", !/[^\x00-\xFF]/.test(locationString) ? locationString : encodeURI(locationString));
+        return this.newResponse(null, status ?? 302);
+      };
+      /**
+      * `.notFound()` can return the Not Found Response.
+      *
+      * @see {@link https://hono.dev/docs/api/context#notfound}
+      *
+      * @example
+      * ```ts
+      * app.get('/notfound', (c) => {
+      *   return c.notFound()
+      * })
+      * ```
+      */
+      notFound = () => {
+        this.#notFoundHandler ??= () => createResponseInstance();
+        return this.#notFoundHandler(this);
+      };
+    };
+    exports2.Context = Context;
+    exports2.TEXT_PLAIN = TEXT_PLAIN;
+  }
+});
+
+// node_modules/hono/dist/cjs/compose.js
+var require_compose = __commonJS({
+  "node_modules/hono/dist/cjs/compose.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var compose = (middleware, onError, onNotFound) => {
+      return (context, next) => {
+        let index = -1;
+        return dispatch(0);
+        async function dispatch(i) {
+          if (i <= index) throw new Error("next() called multiple times");
+          index = i;
+          let res;
+          let isError = false;
+          let handler;
+          if (middleware[i]) {
+            handler = middleware[i][0][0];
+            context.req.routeIndex = i;
+          } else handler = i === middleware.length && next || void 0;
+          if (handler) try {
+            res = await handler(context, () => dispatch(i + 1));
+          } catch (err) {
+            if (err instanceof Error && onError) {
+              context.error = err;
+              res = await onError(err, context);
+              isError = true;
+            } else throw err;
+          }
+          else if (context.finalized === false && onNotFound) res = await onNotFound(context);
+          if (res && (context.finalized === false || isError)) context.res = res;
+          return context;
+        }
+      };
+    };
+    exports2.compose = compose;
+  }
+});
+
+// node_modules/hono/dist/cjs/helper/route/index.js
+var require_route = __commonJS({
+  "node_modules/hono/dist/cjs/helper/route/index.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_request_constants = require_constants();
+    var require_utils_url = require_url();
+    var matchedRoutes = (c) => c.req[require_request_constants.GET_MATCH_RESULT][0].map(([[, route]]) => route);
+    var routePath = (c, index) => matchedRoutes(c).at(index ?? c.req.routeIndex)?.path ?? "";
+    var baseRoutePath = (c, index) => matchedRoutes(c).at(index ?? c.req.routeIndex)?.basePath ?? "";
+    var basePathCacheMap = /* @__PURE__ */ new WeakMap();
+    var basePath = (c, index) => {
+      index ??= c.req.routeIndex;
+      const cache = basePathCacheMap.get(c) || [];
+      if (typeof cache[index] === "string") return cache[index];
+      let result;
+      const rp = baseRoutePath(c, index);
+      if (!/[:*]/.test(rp)) result = rp;
+      else {
+        const paths = require_utils_url.splitRoutingPath(rp);
+        const reqPath = c.req.path;
+        let basePathLength = 0;
+        for (let i = 0, len = paths.length; i < len; i++) {
+          const pattern = require_utils_url.getPattern(paths[i], paths[i + 1]);
+          if (pattern) {
+            const re = pattern[2] === true || pattern === "*" ? /[^\/]+/ : pattern[2];
+            const restPath = reqPath.substring(basePathLength + 1);
+            const segment = restPath.split("/", 1)[0];
+            basePathLength += (restPath.match(re)?.[0] ?? (re.test(segment) ? segment : "")).length;
+          } else basePathLength += paths[i].length;
+          basePathLength += 1;
+        }
+        result = reqPath.substring(0, basePathLength);
+      }
+      cache[index] = result;
+      basePathCacheMap.set(c, cache);
+      return result;
+    };
+    exports2.basePath = basePath;
+    exports2.baseRoutePath = baseRoutePath;
+    exports2.matchedRoutes = matchedRoutes;
+    exports2.routePath = routePath;
+  }
+});
+
+// node_modules/hono/dist/cjs/router.js
+var require_router = __commonJS({
+  "node_modules/hono/dist/cjs/router.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var METHOD_NAME_ALL = "ALL";
+    var METHOD_NAME_ALL_LOWERCASE = "all";
+    var METHODS = [
+      "get",
+      "post",
+      "put",
+      "delete",
+      "options",
+      "patch",
+      "query"
+    ];
+    var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
+    var UnsupportedPathError = class extends Error {
+    };
+    exports2.MESSAGE_MATCHER_IS_ALREADY_BUILT = MESSAGE_MATCHER_IS_ALREADY_BUILT;
+    exports2.METHODS = METHODS;
+    exports2.METHOD_NAME_ALL = METHOD_NAME_ALL;
+    exports2.METHOD_NAME_ALL_LOWERCASE = METHOD_NAME_ALL_LOWERCASE;
+    exports2.UnsupportedPathError = UnsupportedPathError;
+  }
+});
+
+// node_modules/hono/dist/cjs/utils/constants.js
+var require_constants2 = __commonJS({
+  "node_modules/hono/dist/cjs/utils/constants.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var COMPOSED_HANDLER = "__COMPOSED_HANDLER";
+    exports2.COMPOSED_HANDLER = COMPOSED_HANDLER;
+  }
+});
+
+// node_modules/hono/dist/cjs/utils/mount.js
+var require_mount = __commonJS({
+  "node_modules/hono/dist/cjs/utils/mount.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_http_exception2 = require_http_exception();
+    var require_request_constants = require_constants();
+    var require_utils_url = require_url();
+    var countTrailingSlashes = (path) => {
+      let index = path.length;
+      while (index > 0 && path.charCodeAt(index - 1) === 47) index--;
+      return path.length - index;
+    };
+    var getPathPrefixLength = (c, pathPrefix, routePath) => {
+      if (!/[:*]/.test(pathPrefix)) return pathPrefix.length;
+      const path = c.req.path;
+      const matchResult = c.req[require_request_constants.GET_MATCH_RESULT];
+      const paramNames = /* @__PURE__ */ new Set();
+      let length = 0;
+      for (const part of require_utils_url.splitRoutingPath(pathPrefix)) {
+        if (part[0] === ":" && part.endsWith("}?")) throw new Error(`mount(): Optional regular expression parameters are not supported in "${routePath}".`);
+        const pattern = require_utils_url.getPattern(part);
+        if (pattern && pattern !== "*") {
+          const name = pattern[1];
+          if (paramNames.has(name)) throw new Error(`mount(): Duplicate path parameter "${name}" in "${routePath}".`);
+          paramNames.add(name);
+        }
+        if (pattern && pattern !== "*" && pattern[2] !== true) {
+          const value = matchResult.length === 2 ? matchResult[1][matchResult[0][c.req.routeIndex][1][pattern[1]]] : matchResult[0][c.req.routeIndex][1][pattern[1]];
+          length += value.length + 1;
+        } else if (pattern || part.endsWith("*")) {
+          const end = path.indexOf("/", length + 1);
+          length = end === -1 ? path.length : end;
+        } else length += part.length + 1;
+      }
+      return length;
+    };
+    var createMountedRequest = (c, pathPrefix, routePath) => {
+      if (/[^/]\*$/.test(routePath)) throw new Error(`mount(): Wildcard must follow "/" in "${routePath}".`);
+      const prefixLength = getPathPrefixLength(c, pathPrefix, routePath);
+      const path = c.req.path.slice(prefixLength) || "/";
+      if (prefixLength > c.req.path.length || path[0] !== "/" || /\/(?:\.|%2e){1,2}(?:\/|$)/i.test(path)) throw new require_http_exception2.HTTPException(400, { message: "Invalid mounted path" });
+      const rawUrl = c.req.raw.url;
+      if (/^[^/?#]*\/\/[^/?#\\]*[?#\\]/.test(rawUrl)) throw new require_http_exception2.HTTPException(400, { message: "Invalid mounted path" });
+      const rawPathEnd = rawUrl.search(/[?#]/);
+      const rawTrailingSlashes = countTrailingSlashes(rawPathEnd === -1 ? rawUrl : rawUrl.slice(0, rawPathEnd));
+      if (rawTrailingSlashes > 1 && countTrailingSlashes(c.req.path) === rawTrailingSlashes - 1) throw new require_http_exception2.HTTPException(400, { message: "Invalid mounted path" });
+      const url = new URL(rawUrl);
+      url.pathname = path.replace(/[\\\t\n\r]/g, encodeURIComponent);
+      if (path.includes("%")) {
+      }
+      return new Request(url, c.req.raw);
+    };
+    exports2.createMountedRequest = createMountedRequest;
+  }
+});
+
+// node_modules/hono/dist/cjs/hono-base.js
+var require_hono_base = __commonJS({
+  "node_modules/hono/dist/cjs/hono-base.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_compose2 = require_compose();
+    var require_utils_url = require_url();
+    var require_context2 = require_context();
+    var require_helper_route_index = require_route();
+    var require_router5 = require_router();
+    var require_utils_constants = require_constants2();
+    var require_utils_mount = require_mount();
+    var notFoundHandler = (c) => {
+      return c.text("404 Not Found", 404);
+    };
+    var errorHandler = (err, c) => {
+      if ("getResponse" in err) {
+        const res = err.getResponse();
+        return c.newResponse(res.body, res);
+      }
+      console.error(err);
+      return c.text("Internal Server Error", 500);
+    };
+    var Hono = class Hono2 {
+      get;
+      post;
+      put;
+      delete;
+      options;
+      patch;
+      query;
+      all;
+      on;
+      use;
+      router;
+      getPath;
+      _basePath = "/";
+      #path = "/";
+      routes = [];
+      constructor(options = {}) {
+        [...require_router5.METHODS, "all"].forEach((method) => {
+          this[method] = (args1, ...args) => {
+            const methodName = method.toUpperCase();
+            if (typeof args1 === "string") this.#path = args1;
+            else this.#addRoute(methodName, this.#path, args1);
+            args.forEach((handler) => {
+              this.#addRoute(methodName, this.#path, handler);
+            });
+            return this;
+          };
+        });
+        this.on = (method, path, ...handlers) => {
+          for (const p of [path].flat()) {
+            this.#path = p;
+            for (const m of [method].flat()) {
+              const methodName = m.toUpperCase();
+              for (const handler of handlers) this.#addRoute(methodName, this.#path, handler);
+            }
+          }
+          return this;
+        };
+        this.use = (arg1, ...handlers) => {
+          if (typeof arg1 === "string") this.#path = arg1;
+          else {
+            this.#path = "*";
+            handlers.unshift(arg1);
+          }
+          handlers.forEach((handler) => {
+            this.#addRoute("ALL", this.#path, handler);
+          });
+          return this;
+        };
+        const { strict, ...optionsWithoutStrict } = options;
+        Object.assign(this, optionsWithoutStrict);
+        this.getPath = strict ?? true ? options.getPath ?? require_utils_url.getPath : require_utils_url.getPathNoStrict;
+      }
+      #clone() {
+        const clone = new Hono2({
+          router: this.router,
+          getPath: this.getPath
+        });
+        clone.errorHandler = this.errorHandler;
+        clone.#notFoundHandler = this.#notFoundHandler;
+        clone.routes = this.routes;
+        return clone;
+      }
+      #notFoundHandler = notFoundHandler;
+      errorHandler = errorHandler;
+      /**
+      * `.route()` allows grouping other Hono instance in routes.
+      *
+      * @see {@link https://hono.dev/docs/api/routing#grouping}
+      *
+      * @param {string} path - base Path
+      * @param {Hono} app - other Hono instance
+      * @returns {Hono} routed Hono instance
+      *
+      * @example
+      * ```ts
+      * const app = new Hono()
+      * const app2 = new Hono()
+      *
+      * app2.get("/user", (c) => c.text("user"))
+      * app.route("/api", app2) // GET /api/user
+      * ```
+      */
+      route(path, app) {
+        const subApp = this.basePath(path);
+        app.routes.map((r) => {
+          let handler;
+          if (app.errorHandler === errorHandler) handler = r.handler;
+          else {
+            handler = async (c, next) => (await require_compose2.compose([], app.errorHandler)(c, () => r.handler(c, next))).res;
+            handler[require_utils_constants.COMPOSED_HANDLER] = r.handler;
+          }
+          subApp.#addRoute(r.method, r.path, handler, r.basePath);
+        });
+        return this;
+      }
+      /**
+      * `.basePath()` allows base paths to be specified.
+      *
+      * @see {@link https://hono.dev/docs/api/routing#base-path}
+      *
+      * @param {string} path - base Path
+      * @returns {Hono} changed Hono instance
+      *
+      * @example
+      * ```ts
+      * const api = new Hono().basePath('/api')
+      * ```
+      */
+      basePath(path) {
+        const subApp = this.#clone();
+        subApp._basePath = require_utils_url.mergePath(this._basePath, path);
+        return subApp;
+      }
+      /**
+      * `.onError()` handles an error and returns a customized Response.
+      *
+      * @see {@link https://hono.dev/docs/api/hono#error-handling}
+      *
+      * @param {ErrorHandler} handler - request Handler for error
+      * @returns {Hono} changed Hono instance
+      *
+      * @example
+      * ```ts
+      * app.onError((err, c) => {
+      *   console.error(`${err}`)
+      *   return c.text('Custom Error Message', 500)
+      * })
+      * ```
+      */
+      onError = (handler) => {
+        this.errorHandler = handler;
+        return this;
+      };
+      /**
+      * `.notFound()` allows you to customize a Not Found Response.
+      *
+      * @see {@link https://hono.dev/docs/api/hono#not-found}
+      *
+      * @param {NotFoundHandler} handler - request handler for not-found
+      * @returns {Hono} changed Hono instance
+      *
+      * @example
+      * ```ts
+      * app.notFound((c) => {
+      *   return c.text('Custom 404 Message', 404)
+      * })
+      * ```
+      */
+      notFound = (handler) => {
+        this.#notFoundHandler = handler;
+        return this;
+      };
+      /**
+      * `.mount()` allows you to mount applications built with other frameworks into your Hono application.
+      *
+      * @deprecated Use `mount()` from `hono/mount` instead. `.mount()` will be removed in v5.
+      *
+      * @see {@link https://hono.dev/docs/api/hono#mount}
+      *
+      * @param {string} path - base Path
+      * @param {Function} applicationHandler - other Request Handler
+      * @param {MountOptions} [options] - options of `.mount()`
+      * @returns {Hono} mounted Hono instance
+      * @throws {Error} If automatic request rewriting encounters duplicate path parameter names or an optional regular expression parameter.
+      * @throws {HTTPException} With status 400 if automatic request rewriting cannot safely preserve the routed path.
+      *
+      * @example
+      * ```ts
+      * import { Router as IttyRouter } from 'itty-router'
+      * import { Hono } from 'hono'
+      * // Create itty-router application
+      * const ittyRouter = IttyRouter()
+      * // GET /itty-router/hello
+      * ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
+      *
+      * const app = new Hono()
+      * app.mount('/itty-router', ittyRouter.handle)
+      * ```
+      *
+      * @example
+      * ```ts
+      * const app = new Hono()
+      * // Send the request to another application without modification.
+      * app.mount('/app', anotherApp, {
+      *   replaceRequest: (req) => req,
+      * })
+      * ```
+      */
+      mount(path, applicationHandler, options) {
+        let replaceRequest;
+        let optionHandler;
+        if (options) {
+          if (typeof options === "function") optionHandler = options;
+          else {
+            optionHandler = options.optionHandler;
+            if (options.replaceRequest === false) replaceRequest = (request) => request;
+            else replaceRequest = options.replaceRequest;
+          }
+        }
+        const getOptions = optionHandler ? (c) => {
+          const options2 = optionHandler(c);
+          return Array.isArray(options2) ? options2 : [options2];
+        } : (c) => {
+          let executionContext = void 0;
+          try {
+            executionContext = c.executionCtx;
+          } catch {
+          }
+          return [c.env, executionContext];
+        };
+        const defaultReplaceRequest = (c) => {
+          const mountedRoutePath = require_helper_route_index.routePath(c);
+          return require_utils_mount.createMountedRequest(c, mountedRoutePath.replace(/\/?\*$/, ""), mountedRoutePath);
+        };
+        const handler = async (c, next) => {
+          const res = await applicationHandler(replaceRequest ? replaceRequest(c.req.raw) : defaultReplaceRequest(c), ...getOptions(c));
+          if (res) return res;
+          await next();
+        };
+        this.#addRoute("ALL", require_utils_url.mergePath(path, "*"), handler);
+        return this;
+      }
+      #addRoute(method, path, handler, baseRoutePath) {
+        path = require_utils_url.mergePath(this._basePath, path);
+        const r = {
+          basePath: baseRoutePath !== void 0 ? require_utils_url.mergePath(this._basePath, baseRoutePath) : this._basePath,
+          path,
+          method,
+          handler
+        };
+        this.router.add(method, path, [handler, r]);
+        this.routes.push(r);
+      }
+      #handleError(err, c) {
+        if (err instanceof Error) return this.errorHandler(err, c);
+        throw err;
+      }
+      #dispatch(request, executionCtx, env, method) {
+        if (method === "HEAD") return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
+        const path = this.getPath(request, { env });
+        const matchResult = this.router.match(method, path);
+        const c = new require_context2.Context(request, {
+          path,
+          matchResult,
+          env,
+          executionCtx,
+          notFoundHandler: this.#notFoundHandler
+        });
+        if (matchResult[0].length === 1) {
+          let res;
+          try {
+            res = matchResult[0][0][0][0](c, async () => {
+              c.res = await this.#notFoundHandler(c);
+            });
+          } catch (err) {
+            return this.#handleError(err, c);
+          }
+          return res instanceof Promise ? res.then((resolved) => resolved || (c.finalized ? c.res : this.#notFoundHandler(c))).catch((err) => this.#handleError(err, c)) : res ?? this.#notFoundHandler(c);
+        }
+        const composed = require_compose2.compose(matchResult[0], this.errorHandler, this.#notFoundHandler);
+        return (async () => {
+          try {
+            const context = await composed(c);
+            if (!context.finalized) throw new Error("Context is not finalized. Did you forget to return a Response object or `await next()`?");
+            return context.res;
+          } catch (err) {
+            return this.#handleError(err, c);
+          }
+        })();
+      }
+      /**
+      * `.fetch()` will be entry point of your app.
+      *
+      * @see {@link https://hono.dev/docs/api/hono#fetch}
+      *
+      * @param {Request} request - request Object of request
+      * @param {Env} env - env Object
+      * @param {ExecutionContext} executionCtx - context of execution
+      * @returns {Response | Promise<Response>} response of request
+      *
+      */
+      fetch = (request, ...rest) => {
+        return this.#dispatch(request, rest[1], rest[0], request.method);
+      };
+      /**
+      * `.request()` is a useful method for testing.
+      * You can pass a URL or pathname to send a GET request.
+      * app will return a Response object.
+      * ```ts
+      * test('GET /hello is ok', async () => {
+      *   const res = await app.request('/hello')
+      *   expect(res.status).toBe(200)
+      * })
+      * ```
+      * @see https://hono.dev/docs/api/hono#request
+      */
+      request = (input, requestInit, Env, executionCtx) => {
+        if (input instanceof Request) return this.fetch(requestInit ? new Request(input, requestInit) : input, Env, executionCtx);
+        input = input.toString();
+        return this.fetch(new Request(/^https?:\/\//.test(input) ? input : `http://localhost${require_utils_url.mergePath("/", input)}`, requestInit), Env, executionCtx);
+      };
+      /**
+      * `.fire()` automatically adds a global fetch event listener.
+      * This can be useful for environments that adhere to the Service Worker API, such as non-ES module Cloudflare Workers.
+      * @deprecated
+      * Use `fire` from `hono/service-worker` instead.
+      * ```ts
+      * import { Hono } from 'hono'
+      * import { fire } from 'hono/service-worker'
+      *
+      * const app = new Hono()
+      * // ...
+      * fire(app)
+      * ```
+      * @see https://hono.dev/docs/api/hono#fire
+      * @see https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
+      * @see https://developers.cloudflare.com/workers/reference/migrate-to-module-workers/
+      */
+      fire = () => {
+        addEventListener("fetch", (event) => {
+          event.respondWith(this.#dispatch(event.request, event, void 0, event.request.method));
+        });
+      };
+    };
+    exports2.HonoBase = Hono;
+  }
+});
+
+// node_modules/hono/dist/cjs/router/utils.js
+var require_utils = __commonJS({
+  "node_modules/hono/dist/cjs/router/utils.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var createNullObject = () => /* @__PURE__ */ Object.create(null);
+    exports2.createNullObject = createNullObject;
+  }
+});
+
+// node_modules/hono/dist/cjs/router/reg-exp-router/matcher.js
+var require_matcher = __commonJS({
+  "node_modules/hono/dist/cjs/router/reg-exp-router/matcher.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    require_router();
+    var emptyParam = [];
+    function match(method, path) {
+      const matchers = this.buildAllMatchers();
+      const match2 = (method2, path2) => {
+        const matcher = matchers[method2] || matchers["ALL"];
+        const staticMatch = matcher[2][path2];
+        if (staticMatch) return staticMatch;
+        const match3 = path2.match(matcher[0]);
+        if (!match3) return [[], emptyParam];
+        const index = match3.indexOf("", 1);
+        return [matcher[1][index], match3];
+      };
+      this.match = match2;
+      return match2(method, path);
+    }
+    exports2.emptyParam = emptyParam;
+    exports2.match = match;
+  }
+});
+
+// node_modules/hono/dist/cjs/router/reg-exp-router/node.js
+var require_node = __commonJS({
+  "node_modules/hono/dist/cjs/router/reg-exp-router/node.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_router_utils = require_utils();
+    var LABEL_REG_EXP_STR = "[^/]+";
+    var ONLY_WILDCARD_REG_EXP_STR = "[^]*";
+    var TAIL_WILDCARD_REG_EXP_STR = "(?:|/[^]*)";
+    var PATH_ERROR = Symbol();
+    var regExpMetaChars = /* @__PURE__ */ new Set(".\\+*[^]$()");
+    function compareKey(a, b) {
+      if (a.length === 1) return b.length === 1 ? a < b ? -1 : 1 : -1;
+      if (b.length === 1) return 1;
+      if (a === "[^]*" || a === "(?:|/[^]*)") return b === "[^]*" ? -1 : 1;
+      else if (b === "[^]*" || b === "(?:|/[^]*)") return -1;
+      if (a === "[^/]+") return 1;
+      else if (b === "[^/]+") return -1;
+      return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
+    }
+    var Node = class Node2 {
+      #index;
+      #varIndex;
+      #children = require_router_utils.createNullObject();
+      insert(tokens, index, paramMap, context, keys) {
+        let node = this;
+        for (let i = 0, len = tokens.length; i < len; i++) {
+          const token = tokens[i];
+          const pattern = token.length === 1 ? token === "*" ? i === len - 1 ? [
+            "",
+            "",
+            ONLY_WILDCARD_REG_EXP_STR
+          ] : [
+            "",
+            "",
+            LABEL_REG_EXP_STR
+          ] : null : token === "/*" ? [
+            "",
+            "",
+            TAIL_WILDCARD_REG_EXP_STR
+          ] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+          let nextNode;
+          if (pattern) {
+            const name = pattern[1];
+            let regexpStr = pattern[2] || "[^/]+";
+            if (name && pattern[2]) {
+              if (new RegExp(regexpStr).test("")) throw PATH_ERROR;
+              regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:");
+              if (/\((?!\?:)/.test(regexpStr)) throw PATH_ERROR;
+              if (regexpStr.length === 1 && regExpMetaChars.has(regexpStr)) throw PATH_ERROR;
+            }
+            keys.push(regexpStr);
+            nextNode = node.#children[regexpStr];
+            if (!nextNode) {
+              if (regexpStr !== "[^]*" && regexpStr !== "(?:|/[^]*)") {
+                for (const k in node.#children) if ((regexpStr.length > 1 || k.length > 1) && k !== "[^]*" && k !== "(?:|/[^]*)") throw PATH_ERROR;
+              }
+              nextNode = node.#children[regexpStr] = new Node2();
+            }
+            if (name !== "") {
+              nextNode.#varIndex ??= context.varIndex++;
+              paramMap.push([name, nextNode.#varIndex]);
+            }
+          } else {
+            keys.push(token);
+            nextNode = node.#children[token];
+            if (!nextNode) {
+              for (const k in node.#children) if (k.length > 1 && k !== "[^]*" && k !== "(?:|/[^]*)") throw PATH_ERROR;
+              nextNode = node.#children[token] = new Node2();
+            }
+          }
+          node = nextNode;
+        }
+        if (node.#index !== void 0) throw PATH_ERROR;
+        node.#index = index;
+      }
+      buildRegExpStr() {
+        const strList = Object.keys(this.#children).sort(compareKey).map((k) => {
+          const c = this.#children[k];
+          const childStr = c.buildRegExpStr();
+          return childStr === "" ? "" : (typeof c.#varIndex === "number" ? `(${k})@${c.#varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + childStr;
+        }).filter(Boolean);
+        if (typeof this.#index === "number" && this.#index !== -1) strList.unshift(`#${this.#index}`);
+        if (strList.length === 0) return "";
+        if (strList.length === 1) return strList[0];
+        return "(?:" + strList.join("|") + ")";
+      }
+    };
+    exports2.LABEL_REG_EXP_STR = LABEL_REG_EXP_STR;
+    exports2.Node = Node;
+    exports2.ONLY_WILDCARD_REG_EXP_STR = ONLY_WILDCARD_REG_EXP_STR;
+    exports2.PATH_ERROR = PATH_ERROR;
+    exports2.TAIL_WILDCARD_REG_EXP_STR = TAIL_WILDCARD_REG_EXP_STR;
+  }
+});
+
+// node_modules/hono/dist/cjs/router/reg-exp-router/trie.js
+var require_trie = __commonJS({
+  "node_modules/hono/dist/cjs/router/reg-exp-router/trie.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_router_utils = require_utils();
+    var require_router_reg_exp_router_node = require_node();
+    var Trie = class {
+      #context = { varIndex: 0 };
+      #root = new require_router_reg_exp_router_node.Node();
+      #index = 0;
+      paths = require_router_utils.createNullObject();
+      insert(path, isStatic) {
+        const keys = [];
+        if (isStatic) {
+          this.#root.insert(path.split(""), -1, [], this.#context, keys);
+          this.paths[path] = [
+            -1,
+            [],
+            keys
+          ];
+          return;
+        }
+        const paramAssoc = [];
+        const groups = [];
+        let markedPath = path;
+        for (let i = 0; ; ) {
+          let replaced = false;
+          markedPath = markedPath.replace(/\{(?:\{[\d,]+\}|[^}])+\}/g, (m) => {
+            const mark = `@\\${i}`;
+            groups[i] = [mark, m];
+            i++;
+            replaced = true;
+            return mark;
+          });
+          if (!replaced) break;
+        }
+        const tokens = markedPath.match(/(?::[^\/]+)|(?:\/\*$)|./gs) || [];
+        for (let i = groups.length - 1; i >= 0; i--) {
+          const [mark] = groups[i];
+          for (let j = tokens.length - 1; j >= 0; j--) if (tokens[j].indexOf(mark) !== -1) {
+            tokens[j] = tokens[j].replace(mark, groups[i][1]);
+            break;
+          }
+        }
+        this.#root.insert(tokens, this.#index, paramAssoc, this.#context, keys);
+        this.paths[path] = [
+          this.#index++,
+          paramAssoc,
+          keys
+        ];
+      }
+      buildRegExp() {
+        let regexp = this.#root.buildRegExpStr();
+        if (regexp === "") return [
+          /^$/,
+          [],
+          []
+        ];
+        let captureIndex = 0;
+        const indexReplacementMap = [];
+        const paramReplacementMap = [];
+        regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
+          if (handlerIndex !== void 0) {
+            indexReplacementMap[++captureIndex] = Number(handlerIndex);
+            return "$()";
+          }
+          if (paramIndex !== void 0) {
+            paramReplacementMap[Number(paramIndex)] = ++captureIndex;
+            return "";
+          }
+          return "";
+        });
+        return [
+          new RegExp(`^${regexp}`),
+          indexReplacementMap,
+          paramReplacementMap
+        ];
+      }
+    };
+    exports2.Trie = Trie;
+  }
+});
+
+// node_modules/hono/dist/cjs/router/reg-exp-router/router.js
+var require_router2 = __commonJS({
+  "node_modules/hono/dist/cjs/router/reg-exp-router/router.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_utils_url = require_url();
+    var require_router5 = require_router();
+    var require_router_utils = require_utils();
+    var require_router_reg_exp_router_matcher = require_matcher();
+    var require_router_reg_exp_router_node = require_node();
+    var require_router_reg_exp_router_trie = require_trie();
+    function endsWithWildcard(keys) {
+      const tail = keys[keys.length - 1];
+      return tail === "[^]*" || tail === "(?:|/[^]*)";
+    }
+    function covers(wildcard, target) {
+      const last = wildcard.length - 1;
+      for (let i = 0; i < last; i++) if (wildcard[i] !== target[i]) return false;
+      return wildcard[last] === "[^]*" || target.length === last || target[last] === "/";
+    }
+    var RegExpRouter = class {
+      name = "RegExpRouter";
+      #handlers;
+      #tries;
+      constructor() {
+        this.#handlers = { ["ALL"]: [] };
+        this.#tries = { ["ALL"]: new require_router_reg_exp_router_trie.Trie() };
+      }
+      #insertPath(method, path) {
+        try {
+          this.#tries[method].insert(path, !/\*|\/:/.test(path));
+        } catch (e) {
+          throw e === require_router_reg_exp_router_node.PATH_ERROR ? new require_router5.UnsupportedPathError(path) : e;
+        }
+      }
+      add(method, path, handler) {
+        const handlers = this.#handlers;
+        if (!handlers) throw new Error(require_router5.MESSAGE_MATCHER_IS_ALREADY_BUILT);
+        const tries = this.#tries;
+        if (!handlers[method]) {
+          tries[method] = new require_router_reg_exp_router_trie.Trie();
+          handlers[method] = [...handlers["ALL"]];
+          for (const p in tries["ALL"].paths) this.#insertPath(method, p);
+        }
+        if (path === "/*") path = "*";
+        const methods = method === "ALL" ? Object.keys(handlers) : [method];
+        const paths = require_utils_url.checkOptionalParameter(path) || [path];
+        for (const path2 of paths) for (const m of methods) {
+          if (!tries[m].paths[path2]) this.#insertPath(m, path2);
+          handlers[m].push([handler, path2]);
+        }
+      }
+      match = require_router_reg_exp_router_matcher.match;
+      buildAllMatchers() {
+        const matchers = require_router_utils.createNullObject();
+        for (const method of Object.keys(this.#handlers)) matchers[method] = this.#buildMatcher(method);
+        this.#handlers = this.#tries = void 0;
+        return matchers;
+      }
+      #buildMatcher(method) {
+        const handlers = this.#handlers[method];
+        const trie = this.#tries[method];
+        const staticMap = require_router_utils.createNullObject();
+        const handlerData = [];
+        const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
+        const own = require_router_utils.createNullObject();
+        const entries = handlers.map(([h, p], i) => {
+          (own[p] ??= []).push(i);
+          return [h, trie.paths[p][1].reduceRight((map, [key, varIndex]) => {
+            map[key] = paramReplacementMap[varIndex];
+            return map;
+          }, require_router_utils.createNullObject())];
+        });
+        const wildcards = Object.keys(own).filter((p) => endsWithWildcard(trie.paths[p][2]));
+        for (const path in trie.paths) {
+          const [index, , keys] = trie.paths[path];
+          const indexes = [...own[path]];
+          for (const p of wildcards) if (p !== path && covers(trie.paths[p][2], keys)) indexes.push(...own[p]);
+          const data = indexes.sort((a, b) => a - b).map((i) => entries[i]);
+          if (index === -1) {
+            const last = Math.max(-1, ...data.flatMap(([, map]) => Object.values(map)));
+            staticMap[path] = [data, last === -1 ? require_router_reg_exp_router_matcher.emptyParam : path.match(regexp).slice(0, last + 1)];
+          } else handlerData[index] = data;
+        }
+        return [
+          regexp,
+          indexReplacementMap.map((i) => handlerData[i]),
+          staticMap
+        ];
+      }
+    };
+    exports2.RegExpRouter = RegExpRouter;
+  }
+});
+
+// node_modules/hono/dist/cjs/router/smart-router/router.js
+var require_router3 = __commonJS({
+  "node_modules/hono/dist/cjs/router/smart-router/router.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_router5 = require_router();
+    var SmartRouter = class {
+      name = "SmartRouter";
+      #routers = [];
+      #routes = [];
+      constructor(init) {
+        this.#routers = init.routers;
+      }
+      add(method, path, handler) {
+        if (!this.#routes) throw new Error(require_router5.MESSAGE_MATCHER_IS_ALREADY_BUILT);
+        this.#routes.push([
+          method,
+          path,
+          handler
+        ]);
+      }
+      match(method, path) {
+        if (!this.#routes) throw new Error("Fatal error");
+        const routers = this.#routers;
+        const routes = this.#routes;
+        const len = routers.length;
+        let i = 0;
+        let res;
+        for (; i < len; i++) {
+          const router = routers[i];
+          try {
+            for (let i2 = 0, len2 = routes.length; i2 < len2; i2++) router.add(...routes[i2]);
+            res = router.match(method, path);
+          } catch (e) {
+            if (e instanceof require_router5.UnsupportedPathError) continue;
+            throw e;
+          }
+          this.match = router.match.bind(router);
+          this.#routers = [router];
+          this.#routes = void 0;
+          break;
+        }
+        if (i === len) throw new Error("Fatal error");
+        this.name = `SmartRouter + ${this.activeRouter.name}`;
+        return res;
+      }
+      get activeRouter() {
+        if (this.#routes || this.#routers.length !== 1) throw new Error("No active router has been determined yet.");
+        return this.#routers[0];
+      }
+    };
+    exports2.SmartRouter = SmartRouter;
+  }
+});
+
+// node_modules/hono/dist/cjs/router/trie-router/node.js
+var require_node2 = __commonJS({
+  "node_modules/hono/dist/cjs/router/trie-router/node.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_utils_url = require_url();
+    require_router();
+    var require_router_utils = require_utils();
+    var emptyParams = require_router_utils.createNullObject();
+    var order = 0;
+    var Node = class Node2 {
+      #methods = [];
+      #children = require_router_utils.createNullObject();
+      #patterns = [];
+      #pattern;
+      #params = emptyParams;
+      insert(method, path, handler) {
+        let curNode = this;
+        const parts = require_utils_url.splitRoutingPath(path);
+        const possibleKeys = /* @__PURE__ */ new Set();
+        let i = 0;
+        for (const p of parts) {
+          const nextP = parts[++i];
+          const pattern = require_utils_url.getPattern(p, nextP) || (nextP === void 0 && p && p.indexOf("*") === p.length - 1 ? p : null);
+          const isParam = Array.isArray(pattern);
+          const key = isParam ? pattern[0] : pattern || p;
+          const child = curNode.#children[key] ||= new Node2();
+          if (pattern && !child.#pattern) {
+            child.#pattern = pattern;
+            curNode.#patterns.push(child);
+          }
+          curNode = child;
+          if (isParam) possibleKeys.add(pattern[1]);
+        }
+        curNode.#methods.push({ [method]: {
+          handler,
+          possibleKeys: [...possibleKeys],
+          score: ++order
+        } });
+      }
+      #pushHandlerSets(handlerSets, node, method, nodeParams, params) {
+        for (let i = 0, len = node.#methods.length; i < len; i++) {
+          const m = node.#methods[i];
+          const handlerSet = m[method] || m["ALL"];
+          if (handlerSet) {
+            handlerSet.params = require_router_utils.createNullObject();
+            handlerSets.push(handlerSet);
+            for (let i2 = 0, len2 = handlerSet.possibleKeys.length; i2 < len2; i2++) {
+              const key = handlerSet.possibleKeys[i2];
+              handlerSet.params[key] = params?.[key] && !i2 ? params[key] : nodeParams[key] ?? params?.[key];
+            }
+          }
+        }
+      }
+      search(method, path) {
+        const handlerSets = [];
+        this.#params = emptyParams;
+        let curNodes = [this];
+        const parts = require_utils_url.splitPath(path);
+        const curNodesQueue = [];
+        const len = parts.length;
+        let partOffsets = null;
+        for (let i = 0; i < len; i++) {
+          const part = parts[i];
+          const isLast = i === len - 1;
+          const tempNodes = [];
+          for (let j = 0, len2 = curNodes.length; j < len2; j++) {
+            const node = curNodes[j];
+            const nextNode = node.#children[part];
+            if (nextNode) {
+              nextNode.#params = node.#params;
+              if (isLast) {
+                if (nextNode.#children["*"]) this.#pushHandlerSets(handlerSets, nextNode.#children["*"], method, node.#params);
+                this.#pushHandlerSets(handlerSets, nextNode, method, node.#params);
+              } else tempNodes.push(nextNode);
+            }
+            for (const child of node.#patterns) {
+              const pattern = child.#pattern;
+              const params = node.#params === emptyParams ? {} : { ...node.#params };
+              if (typeof pattern === "string") {
+                if (pattern === "*" || part.startsWith(pattern.slice(0, -1))) {
+                  this.#pushHandlerSets(handlerSets, child, method, node.#params);
+                  if (pattern === "*") {
+                    child.#params = params;
+                    tempNodes.push(child);
+                  }
+                }
+                continue;
+              }
+              const [, name, matcher] = pattern;
+              if (!part && matcher === true) continue;
+              if (matcher !== true) {
+                if (!partOffsets) {
+                  partOffsets = [];
+                  let offset = path[0] === "/" ? 1 : 0;
+                  for (let p = 0; p < len; p++) {
+                    partOffsets[p] = offset;
+                    offset += parts[p].length + 1;
+                  }
+                }
+                const restPathString = path.slice(partOffsets[i]);
+                const m = matcher.exec(restPathString);
+                if (m) {
+                  if (!Object.hasOwn(params, name)) params[name] = m[0];
+                  this.#pushHandlerSets(handlerSets, child, method, node.#params, params);
+                  if (m[0].length === restPathString.length && child.#children["*"]) this.#pushHandlerSets(handlerSets, child.#children["*"], method, node.#params, params);
+                  for (const _ in child.#children) {
+                    child.#params = params;
+                    const componentCount = m[0].match(/\//g)?.length ?? 0;
+                    (curNodesQueue[componentCount] ||= []).push(child);
+                    break;
+                  }
+                  continue;
+                }
+              }
+              if (matcher === true || matcher.test(part)) {
+                if (!Object.hasOwn(params, name)) params[name] = part;
+                if (isLast) {
+                  this.#pushHandlerSets(handlerSets, child, method, params, node.#params);
+                  if (child.#children["*"]) this.#pushHandlerSets(handlerSets, child.#children["*"], method, params, node.#params);
+                } else {
+                  child.#params = params;
+                  tempNodes.push(child);
+                }
+              }
+            }
+          }
+          const shifted = curNodesQueue.shift();
+          curNodes = shifted ? tempNodes.concat(shifted) : tempNodes;
+        }
+        if (handlerSets[1]) handlerSets.sort((a, b) => {
+          return a.score - b.score;
+        });
+        return [handlerSets.map(({ handler, params }) => [handler, params])];
+      }
+    };
+    exports2.Node = Node;
+  }
+});
+
+// node_modules/hono/dist/cjs/router/trie-router/router.js
+var require_router4 = __commonJS({
+  "node_modules/hono/dist/cjs/router/trie-router/router.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_utils_url = require_url();
+    var require_router_trie_router_node = require_node2();
+    var TrieRouter = class {
+      name = "TrieRouter";
+      #node = new require_router_trie_router_node.Node();
+      add(method, path, handler) {
+        for (const result of require_utils_url.checkOptionalParameter(path) || [path]) this.#node.insert(method, result, handler);
+      }
+      match(method, path) {
+        return this.#node.search(method, path);
+      }
+    };
+    exports2.TrieRouter = TrieRouter;
+  }
+});
+
+// node_modules/hono/dist/cjs/router/trie-router/index.js
+var require_trie_router = __commonJS({
+  "node_modules/hono/dist/cjs/router/trie-router/index.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_router_trie_router_router = require_router4();
+    exports2.TrieRouter = require_router_trie_router_router.TrieRouter;
+  }
+});
+
+// node_modules/hono/dist/cjs/hono.js
+var require_hono = __commonJS({
+  "node_modules/hono/dist/cjs/hono.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_hono_base2 = require_hono_base();
+    var require_router_reg_exp_router_router = require_router2();
+    var require_router_smart_router_router = require_router3();
+    var require_router_trie_router_router = require_router4();
+    require_trie_router();
+    var Hono = class extends require_hono_base2.HonoBase {
+      /**
+      * Creates an instance of the Hono class.
+      *
+      * @param options - Optional configuration options for the Hono instance.
+      */
+      constructor(options = {}) {
+        super(options);
+        this.router = options.router ?? new require_router_smart_router_router.SmartRouter({ routers: [new require_router_reg_exp_router_router.RegExpRouter(), new require_router_trie_router_router.TrieRouter()] });
+      }
+    };
+    exports2.Hono = Hono;
+  }
+});
+
+// node_modules/hono/dist/cjs/index.js
+var require_cjs = __commonJS({
+  "node_modules/hono/dist/cjs/index.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_context2 = require_context();
+    var require_hono3 = require_hono();
+    exports2.Context = require_context2.Context;
+    exports2.Hono = require_hono3.Hono;
+  }
+});
+
+// node_modules/@hono/node-server/dist/index.js
+var require_dist = __commonJS({
+  "node_modules/@hono/node-server/dist/index.js"(exports2, module2) {
+    "use strict";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var src_exports = {};
+    __export(src_exports, {
+      RequestError: () => RequestError,
+      createAdaptorServer: () => createAdaptorServer,
+      getRequestListener: () => getRequestListener,
+      serve: () => serve
+    });
+    module2.exports = __toCommonJS(src_exports);
+    var import_node_http = require("http");
+    var import_node_http22 = require("http2");
+    var import_node_http2 = require("http2");
+    var import_node_stream = require("stream");
+    var RequestError = class extends Error {
+      constructor(message, options) {
+        super(message, options);
+        this.name = "RequestError";
+      }
+    };
+    var validateRequestTarget = (target) => {
+      const backslash = target.indexOf("\\");
+      if (backslash !== -1) {
+        const query = target.indexOf("?");
+        if (query === -1 || backslash < query) {
+          throw new RequestError("Backslash in request path");
+        }
+      }
+    };
+    var toRequestError = (e) => {
+      if (e instanceof RequestError) {
+        return e;
+      }
+      return new RequestError(e.message, { cause: e });
+    };
+    var GlobalRequest = global.Request;
+    var Request2 = class extends GlobalRequest {
+      constructor(input, options) {
+        if (typeof input === "object" && getRequestCache in input) {
+          input = input[getRequestCache]();
+        }
+        if (typeof options?.body?.getReader !== "undefined") {
+          ;
+          options.duplex ??= "half";
+        }
+        super(input, options);
+      }
+    };
+    var newHeadersFromIncoming = (incoming) => {
+      const headerRecord = [];
+      const rawHeaders = incoming.rawHeaders;
+      for (let i = 0; i < rawHeaders.length; i += 2) {
+        const { [i]: key, [i + 1]: value } = rawHeaders;
+        if (key.charCodeAt(0) !== /*:*/
+        58) {
+          headerRecord.push([key, value]);
+        }
+      }
+      return new Headers(headerRecord);
+    };
+    var wrapBodyStream = Symbol("wrapBodyStream");
+    var newRequestFromIncoming = (method, url, headers, incoming, abortController) => {
+      const init = {
+        method,
+        headers,
+        signal: abortController.signal
+      };
+      if (method === "TRACE") {
+        init.method = "GET";
+        const req = new Request2(url, init);
+        Object.defineProperty(req, "method", {
+          get() {
+            return "TRACE";
+          }
+        });
+        return req;
+      }
+      if (!(method === "GET" || method === "HEAD")) {
+        if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) {
+          init.body = new ReadableStream({
+            start(controller) {
+              controller.enqueue(incoming.rawBody);
+              controller.close();
+            }
+          });
+        } else if (incoming[wrapBodyStream]) {
+          let reader;
+          init.body = new ReadableStream({
+            async pull(controller) {
+              try {
+                reader ||= import_node_stream.Readable.toWeb(incoming).getReader();
+                const { done, value } = await reader.read();
+                if (done) {
+                  controller.close();
+                } else {
+                  controller.enqueue(value);
+                }
+              } catch (error) {
+                controller.error(error);
+              }
+            }
+          });
+        } else {
+          init.body = import_node_stream.Readable.toWeb(incoming);
+        }
+      }
+      return new Request2(url, init);
+    };
+    var getRequestCache = Symbol("getRequestCache");
+    var requestCache = Symbol("requestCache");
+    var incomingKey = Symbol("incomingKey");
+    var urlKey = Symbol("urlKey");
+    var headersKey = Symbol("headersKey");
+    var abortControllerKey = Symbol("abortControllerKey");
+    var getAbortController = Symbol("getAbortController");
+    var requestPrototype = {
+      get method() {
+        return this[incomingKey].method || "GET";
+      },
+      get url() {
+        return this[urlKey];
+      },
+      get headers() {
+        return this[headersKey] ||= newHeadersFromIncoming(this[incomingKey]);
+      },
+      [getAbortController]() {
+        this[getRequestCache]();
+        return this[abortControllerKey];
+      },
+      [getRequestCache]() {
+        this[abortControllerKey] ||= new AbortController();
+        return this[requestCache] ||= newRequestFromIncoming(
+          this.method,
+          this[urlKey],
+          this.headers,
+          this[incomingKey],
+          this[abortControllerKey]
+        );
+      }
+    };
+    [
+      "body",
+      "bodyUsed",
+      "cache",
+      "credentials",
+      "destination",
+      "integrity",
+      "mode",
+      "redirect",
+      "referrer",
+      "referrerPolicy",
+      "signal",
+      "keepalive"
+    ].forEach((k) => {
+      Object.defineProperty(requestPrototype, k, {
+        get() {
+          return this[getRequestCache]()[k];
+        }
+      });
+    });
+    ["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
+      Object.defineProperty(requestPrototype, k, {
+        value: function() {
+          return this[getRequestCache]()[k]();
+        }
+      });
+    });
+    Object.defineProperty(requestPrototype, Symbol.for("nodejs.util.inspect.custom"), {
+      value: function(depth, options, inspectFn) {
+        const props = {
+          method: this.method,
+          url: this.url,
+          headers: this.headers,
+          nativeRequest: this[requestCache]
+        };
+        return `Request (lightweight) ${inspectFn(props, { ...options, depth: depth == null ? null : depth - 1 })}`;
+      }
+    });
+    Object.setPrototypeOf(requestPrototype, Request2.prototype);
+    var newRequest = (incoming, defaultHostname) => {
+      const req = Object.create(requestPrototype);
+      req[incomingKey] = incoming;
+      const incomingUrl = incoming.url || "";
+      if (incomingUrl[0] !== "/" && // short-circuit for performance. most requests are relative URL.
+      (incomingUrl.startsWith("http://") || incomingUrl.startsWith("https://"))) {
+        if (incoming instanceof import_node_http2.Http2ServerRequest) {
+          throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
+        }
+        try {
+          validateRequestTarget(incomingUrl);
+          const url2 = new URL(incomingUrl);
+          req[urlKey] = url2.href;
+        } catch (e) {
+          throw new RequestError("Invalid absolute URL", { cause: e });
+        }
+        return req;
+      }
+      const host = (incoming instanceof import_node_http2.Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
+      if (!host) {
+        throw new RequestError("Missing host header");
+      }
+      let scheme;
+      if (incoming instanceof import_node_http2.Http2ServerRequest) {
+        scheme = incoming.scheme;
+        if (!(scheme === "http" || scheme === "https")) {
+          throw new RequestError("Unsupported scheme");
+        }
+      } else {
+        scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
+      }
+      validateRequestTarget(incomingUrl);
+      const url = new URL(`${scheme}://${host}${incomingUrl}`);
+      if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
+        throw new RequestError("Invalid host header");
+      }
+      req[urlKey] = url.href;
+      return req;
+    };
+    var responseCache = Symbol("responseCache");
+    var getResponseCache = Symbol("getResponseCache");
+    var cacheKey = Symbol("cache");
+    var GlobalResponse = global.Response;
+    var Response2 = class _Response {
+      #body;
+      #init;
+      [getResponseCache]() {
+        delete this[cacheKey];
+        return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
+      }
+      constructor(body, init) {
+        let headers;
+        this.#body = body;
+        if (init instanceof _Response) {
+          const cachedGlobalResponse = init[responseCache];
+          if (cachedGlobalResponse) {
+            this.#init = cachedGlobalResponse;
+            this[getResponseCache]();
+            return;
+          } else {
+            this.#init = init.#init;
+            headers = new Headers(init.#init.headers);
+          }
+        } else {
+          this.#init = init;
+        }
+        if (typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) {
+          ;
+          this[cacheKey] = [init?.status || 200, body, headers || init?.headers];
+        }
+      }
+      get headers() {
+        const cache = this[cacheKey];
+        if (cache) {
+          if (!(cache[2] instanceof Headers)) {
+            cache[2] = new Headers(
+              cache[2] || { "content-type": "text/plain; charset=UTF-8" }
+            );
+          }
+          return cache[2];
+        }
+        return this[getResponseCache]().headers;
+      }
+      get status() {
+        return this[cacheKey]?.[0] ?? this[getResponseCache]().status;
+      }
+      get ok() {
+        const status = this.status;
+        return status >= 200 && status < 300;
+      }
+    };
+    ["body", "bodyUsed", "redirected", "statusText", "trailers", "type", "url"].forEach((k) => {
+      Object.defineProperty(Response2.prototype, k, {
+        get() {
+          return this[getResponseCache]()[k];
+        }
+      });
+    });
+    ["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
+      Object.defineProperty(Response2.prototype, k, {
+        value: function() {
+          return this[getResponseCache]()[k]();
+        }
+      });
+    });
+    Object.defineProperty(Response2.prototype, Symbol.for("nodejs.util.inspect.custom"), {
+      value: function(depth, options, inspectFn) {
+        const props = {
+          status: this.status,
+          headers: this.headers,
+          ok: this.ok,
+          nativeResponse: this[responseCache]
+        };
+        return `Response (lightweight) ${inspectFn(props, { ...options, depth: depth == null ? null : depth - 1 })}`;
+      }
+    });
+    Object.setPrototypeOf(Response2, GlobalResponse);
+    Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
+    async function readWithoutBlocking(readPromise) {
+      return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(void 0))]);
+    }
+    function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {
+      const cancel = (error) => {
+        reader.cancel(error).catch(() => {
+        });
+      };
+      writable.on("close", cancel);
+      writable.on("error", cancel);
+      (currentReadPromise ?? reader.read()).then(flow, handleStreamError);
+      return reader.closed.finally(() => {
+        writable.off("close", cancel);
+        writable.off("error", cancel);
+      });
+      function handleStreamError(error) {
+        if (error) {
+          writable.destroy(error);
+        }
+      }
+      function onDrain() {
+        reader.read().then(flow, handleStreamError);
+      }
+      function flow({ done, value }) {
+        try {
+          if (done) {
+            writable.end();
+          } else if (!writable.write(value)) {
+            writable.once("drain", onDrain);
+          } else {
+            return reader.read().then(flow, handleStreamError);
+          }
+        } catch (e) {
+          handleStreamError(e);
+        }
+      }
+    }
+    function writeFromReadableStream(stream, writable) {
+      if (stream.locked) {
+        throw new TypeError("ReadableStream is locked.");
+      } else if (writable.destroyed) {
+        return;
+      }
+      return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
+    }
+    var buildOutgoingHttpHeaders = (headers) => {
+      const res = {};
+      if (!(headers instanceof Headers)) {
+        headers = new Headers(headers ?? void 0);
+      }
+      const cookies = [];
+      for (const [k, v] of headers) {
+        if (k === "set-cookie") {
+          cookies.push(v);
+        } else {
+          res[k] = v;
+        }
+      }
+      if (cookies.length > 0) {
+        res["set-cookie"] = cookies;
+      }
+      res["content-type"] ??= "text/plain; charset=UTF-8";
+      return res;
+    };
+    var X_ALREADY_SENT = "x-hono-already-sent";
+    var import_node_crypto = __toESM2(require("crypto"));
+    if (typeof global.crypto === "undefined") {
+      global.crypto = import_node_crypto.default;
+    }
+    var outgoingEnded = Symbol("outgoingEnded");
+    var incomingDraining = Symbol("incomingDraining");
+    var DRAIN_TIMEOUT_MS = 500;
+    var MAX_DRAIN_BYTES = 64 * 1024 * 1024;
+    var drainIncoming = (incoming) => {
+      const incomingWithDrainState = incoming;
+      if (incoming.destroyed || incomingWithDrainState[incomingDraining]) {
+        return;
+      }
+      incomingWithDrainState[incomingDraining] = true;
+      if (incoming instanceof import_node_http22.Http2ServerRequest) {
+        try {
+          ;
+          incoming.stream?.close?.(import_node_http22.constants.NGHTTP2_NO_ERROR);
+        } catch {
+        }
+        return;
+      }
+      let bytesRead = 0;
+      const cleanup = () => {
+        clearTimeout(timer);
+        incoming.off("data", onData);
+        incoming.off("end", cleanup);
+        incoming.off("error", cleanup);
+      };
+      const forceClose = () => {
+        cleanup();
+        const socket = incoming.socket;
+        if (socket && !socket.destroyed) {
+          socket.destroySoon();
+        }
+      };
+      const timer = setTimeout(forceClose, DRAIN_TIMEOUT_MS);
+      timer.unref?.();
+      const onData = (chunk) => {
+        bytesRead += chunk.length;
+        if (bytesRead > MAX_DRAIN_BYTES) {
+          forceClose();
+        }
+      };
+      incoming.on("data", onData);
+      incoming.on("end", cleanup);
+      incoming.on("error", cleanup);
+      incoming.resume();
+    };
+    var handleRequestError = () => new Response(null, {
+      status: 400
+    });
+    var handleFetchError = (e) => new Response(null, {
+      status: e instanceof Error && (e.name === "TimeoutError" || e.constructor.name === "TimeoutError") ? 504 : 500
+    });
+    var handleResponseError = (e, outgoing) => {
+      const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
+      if (err.code === "ERR_STREAM_PREMATURE_CLOSE") {
+        console.info("The user aborted a request.");
+      } else {
+        console.error(e);
+        if (!outgoing.headersSent) {
+          outgoing.writeHead(500, { "Content-Type": "text/plain" });
+        }
+        outgoing.end(`Error: ${err.message}`);
+        outgoing.destroy(err);
+      }
+    };
+    var flushHeaders = (outgoing) => {
+      if ("flushHeaders" in outgoing && outgoing.writable) {
+        outgoing.flushHeaders();
+      }
+    };
+    var responseViaCache = async (res, outgoing) => {
+      let [status, body, header] = res[cacheKey];
+      let hasContentLength = false;
+      if (!header) {
+        header = { "content-type": "text/plain; charset=UTF-8" };
+      } else if (header instanceof Headers) {
+        hasContentLength = header.has("content-length");
+        header = buildOutgoingHttpHeaders(header);
+      } else if (Array.isArray(header)) {
+        const headerObj = new Headers(header);
+        hasContentLength = headerObj.has("content-length");
+        header = buildOutgoingHttpHeaders(headerObj);
+      } else {
+        for (const key in header) {
+          if (key.length === 14 && key.toLowerCase() === "content-length") {
+            hasContentLength = true;
+            break;
+          }
+        }
+      }
+      if (!hasContentLength) {
+        if (typeof body === "string") {
+          header["Content-Length"] = Buffer.byteLength(body);
+        } else if (body instanceof Uint8Array) {
+          header["Content-Length"] = body.byteLength;
+        } else if (body instanceof Blob) {
+          header["Content-Length"] = body.size;
+        }
+      }
+      outgoing.writeHead(status, header);
+      if (typeof body === "string" || body instanceof Uint8Array) {
+        outgoing.end(body);
+      } else if (body instanceof Blob) {
+        outgoing.end(new Uint8Array(await body.arrayBuffer()));
+      } else {
+        flushHeaders(outgoing);
+        await writeFromReadableStream(body, outgoing)?.catch(
+          (e) => handleResponseError(e, outgoing)
+        );
+      }
+      ;
+      outgoing[outgoingEnded]?.();
+    };
+    var isPromise = (res) => typeof res.then === "function";
+    var responseViaResponseObject = async (res, outgoing, options = {}) => {
+      if (isPromise(res)) {
+        if (options.errorHandler) {
+          try {
+            res = await res;
+          } catch (err) {
+            const errRes = await options.errorHandler(err);
+            if (!errRes) {
+              return;
+            }
+            res = errRes;
+          }
+        } else {
+          res = await res.catch(handleFetchError);
+        }
+      }
+      if (cacheKey in res) {
+        return responseViaCache(res, outgoing);
+      }
+      const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
+      if (res.body) {
+        const reader = res.body.getReader();
+        const values = [];
+        let done = false;
+        let currentReadPromise = void 0;
+        if (resHeaderRecord["transfer-encoding"] !== "chunked") {
+          let maxReadCount = 2;
+          for (let i = 0; i < maxReadCount; i++) {
+            currentReadPromise ||= reader.read();
+            const chunk = await readWithoutBlocking(currentReadPromise).catch((e) => {
+              console.error(e);
+              done = true;
+            });
+            if (!chunk) {
+              if (i === 1) {
+                await new Promise((resolve) => setTimeout(resolve));
+                maxReadCount = 3;
+                continue;
+              }
+              break;
+            }
+            currentReadPromise = void 0;
+            if (chunk.value) {
+              values.push(chunk.value);
+            }
+            if (chunk.done) {
+              done = true;
+              break;
+            }
+          }
+          if (done && !("content-length" in resHeaderRecord)) {
+            resHeaderRecord["content-length"] = values.reduce((acc, value) => acc + value.length, 0);
+          }
+        }
+        outgoing.writeHead(res.status, resHeaderRecord);
+        values.forEach((value) => {
+          ;
+          outgoing.write(value);
+        });
+        if (done) {
+          outgoing.end();
+        } else {
+          if (values.length === 0) {
+            flushHeaders(outgoing);
+          }
+          await writeFromReadableStreamDefaultReader(reader, outgoing, currentReadPromise);
+        }
+      } else if (resHeaderRecord[X_ALREADY_SENT]) {
+      } else {
+        outgoing.writeHead(res.status, resHeaderRecord);
+        outgoing.end();
+      }
+      ;
+      outgoing[outgoingEnded]?.();
+    };
+    var getRequestListener = (fetchCallback, options = {}) => {
+      const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
+      if (options.overrideGlobalObjects !== false && global.Request !== Request2) {
+        Object.defineProperty(global, "Request", {
+          value: Request2
+        });
+        Object.defineProperty(global, "Response", {
+          value: Response2
+        });
+      }
+      return async (incoming, outgoing) => {
+        let res, req;
+        try {
+          req = newRequest(incoming, options.hostname);
+          let incomingEnded = !autoCleanupIncoming || incoming.method === "GET" || incoming.method === "HEAD";
+          if (!incomingEnded) {
+            ;
+            incoming[wrapBodyStream] = true;
+            incoming.on("end", () => {
+              incomingEnded = true;
+            });
+            if (incoming instanceof import_node_http22.Http2ServerRequest) {
+              ;
+              outgoing[outgoingEnded] = () => {
+                if (!incomingEnded) {
+                  setTimeout(() => {
+                    if (!incomingEnded) {
+                      setTimeout(() => {
+                        drainIncoming(incoming);
+                      });
+                    }
+                  });
+                }
+              };
+            }
+            outgoing.on("finish", () => {
+              if (!incomingEnded) {
+                drainIncoming(incoming);
+              }
+            });
+          }
+          outgoing.on("close", () => {
+            const abortController = req[abortControllerKey];
+            if (abortController) {
+              if (incoming.errored) {
+                req[abortControllerKey].abort(incoming.errored.toString());
+              } else if (!outgoing.writableFinished) {
+                req[abortControllerKey].abort("Client connection prematurely closed.");
+              }
+            }
+            if (!incomingEnded) {
+              setTimeout(() => {
+                if (!incomingEnded) {
+                  setTimeout(() => {
+                    drainIncoming(incoming);
+                  });
+                }
+              });
+            }
+          });
+          res = fetchCallback(req, { incoming, outgoing });
+          if (cacheKey in res) {
+            return responseViaCache(res, outgoing);
+          }
+        } catch (e) {
+          if (!res) {
+            if (options.errorHandler) {
+              res = await options.errorHandler(req ? e : toRequestError(e));
+              if (!res) {
+                return;
+              }
+            } else if (!req) {
+              res = handleRequestError();
+            } else {
+              res = handleFetchError(e);
+            }
+          } else {
+            return handleResponseError(e, outgoing);
+          }
+        }
+        try {
+          return await responseViaResponseObject(res, outgoing, options);
+        } catch (e) {
+          return handleResponseError(e, outgoing);
+        }
+      };
+    };
+    var createAdaptorServer = (options) => {
+      const fetchCallback = options.fetch;
+      const requestListener = getRequestListener(fetchCallback, {
+        hostname: options.hostname,
+        overrideGlobalObjects: options.overrideGlobalObjects,
+        autoCleanupIncoming: options.autoCleanupIncoming
+      });
+      const createServer = options.createServer || import_node_http.createServer;
+      const server = createServer(options.serverOptions || {}, requestListener);
+      return server;
+    };
+    var serve = (options, listeningListener) => {
+      const server = createAdaptorServer(options);
+      server.listen(options?.port ?? 3e3, options.hostname, () => {
+        const serverInfo = server.address();
+        listeningListener && listeningListener(serverInfo);
+      });
+      return server;
+    };
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/server/hono/proxy.js
+var require_proxy = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/server/hono/proxy.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    }();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.HonoProxy = void 0;
+    var pengueno_1 = require_dist2();
+    var AppLifetimeMetric = pengueno_1.Metric.fromName("HonoAppLifetime").asResult();
+    var AppRequestMetric = pengueno_1.Metric.fromName("HonoAppRequest");
+    var HonoProxy = class {
+      server;
+      app;
+      constructor(server) {
+        this.server = server;
+      }
+      async initializeApp() {
+        if (this.app)
+          return this.app;
+        const { Hono } = await Promise.resolve().then(() => __importStar(require_cjs()));
+        this.app = pengueno_1.LogMetricTraceable.of(new Hono()).flatMap(pengueno_1.TraceUtil.withTrace(`AppId = ${crypto.randomUUID()}`)).flatMap(pengueno_1.TraceUtil.withMetricTrace(AppLifetimeMetric));
+        return this.app;
+      }
+      async serve(port, hostname) {
+        const { serve } = await Promise.resolve().then(() => __importStar(require_dist()));
+        const app = await this.initializeApp();
+        return app.map((tApp) => pengueno_1.Either.fromFailable(() => {
+          const app2 = tApp.get();
+          app2.all("*", async (c) => tApp.flatMap(pengueno_1.TraceUtil.withMetricTrace(AppRequestMetric)).move(c.req).flatMap((tRequest) => pengueno_1.PenguenoRequest.from(tRequest)).map((req) => this.server.serve(req)).map(pengueno_1.TraceUtil.promiseify((tResponse) => {
+            tResponse.trace.trace(AppRequestMetric.count.withValue(1));
+            return new Response(tResponse.get().body(), tResponse.get());
+          })).get());
+          return serve({
+            fetch: (_r) => app2.fetch(_r),
+            port,
+            hostname
+          });
+        })).peek(pengueno_1.TraceUtil.traceResultingEither()).peek((tServe) => tServe.get().mapRight(() => tServe.trace.trace(`haii im still listening at http://${hostname}:${port} ~uwu dont think i forgot`))).map((tEitherServer) => tEitherServer.get().mapRight((server) => tEitherServer.move(server)).flatMapAsync((tServer) => pengueno_1.Signals.awaitClose(tServer))).peek(pengueno_1.TraceUtil.promiseify(pengueno_1.TraceUtil.traceResultingEither(AppLifetimeMetric))).get();
+      }
+    };
+    exports2.HonoProxy = HonoProxy;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/server/hono/index.js
+var require_hono2 = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/server/hono/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_proxy(), exports2);
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/server/index.js
+var require_server = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/server/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_http(), exports2);
+    __exportStar(require_response(), exports2);
+    __exportStar(require_request(), exports2);
+    __exportStar(require_activity(), exports2);
+    __exportStar(require_filter(), exports2);
+    __exportStar(require_hono2(), exports2);
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/index.js
+var require_dist2 = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_leftpadesque(), exports2);
+    __exportStar(require_types(), exports2);
+    __exportStar(require_trace4(), exports2);
+    __exportStar(require_process(), exports2);
+    __exportStar(require_server(), exports2);
+  }
+});
+
+// node_modules/@emprespresso/ci_model/dist/job/index.js
+var import_pengueno = __toESM(require_dist2(), 1);
+var JobTypes = [
+  "fetch_code",
+  "ci_pipeline",
+  "build_docker_image.js",
+  "ansible_playbook.js",
+  "checkout_ci.js",
+  "npm_publish.js",
+  "coolify_webhook.js"
+];
+var isJobType = (j) => typeof j === "string" && JobTypes.includes(j);
+var isJob = (j) => !!((0, import_pengueno.isObject)(j) && "arguments" in j && (0, import_pengueno.isObject)(j.arguments) && "type" in j && isJobType(j.type) && j);
+
+// node_modules/@emprespresso/ci_model/dist/pipeline/index.js
+var import_pengueno3 = __toESM(require_dist2(), 1);
+
+// node_modules/@emprespresso/ci_model/dist/pipeline/builder.js
+var BasePipelineBuilder = class {
+  stages = [];
+  addStage(stage) {
+    this.stages.push(stage);
+    return this;
+  }
+  build() {
+    return new PipelineImpl(this.stages);
+  }
+};
+var DefaultGitHookPipelineBuilder = class extends BasePipelineBuilder {
+  remoteUrl;
+  rev;
+  refname;
+  constructor(remoteUrl = process.env.remote, rev = process.env.rev, refname = process.env.refname) {
+    super();
+    this.remoteUrl = remoteUrl;
+    this.rev = rev;
+    this.refname = refname;
+    this.addStage({
+      parallelJobs: [
+        {
+          type: "fetch_code",
+          arguments: {
+            remoteUrl,
+            checkout: rev,
+            path: this.getSourceDestination()
+          }
+        }
+      ]
+    });
+  }
+  getSourceDestination() {
+    return this.remoteUrl.replace(".git", "").split("/").at(-1) ?? "src";
+  }
+  getRev() {
+    return this.rev;
+  }
+  getBranch() {
+    const branchRefPrefix = "refs/heads/";
+    return this.refname.split(branchRefPrefix).at(1);
+  }
+};
+
+// node_modules/@emprespresso/ci_model/dist/pipeline/impl.js
+var import_pengueno2 = __toESM(require_dist2(), 1);
+var PipelineImpl = class _PipelineImpl {
+  serialJobs;
+  constructor(serialJobs) {
+    this.serialJobs = serialJobs;
+  }
+  serialize() {
+    return JSON.stringify({ serialJobs: this.serialJobs });
+  }
+  static from(s) {
+    return import_pengueno2.Either.fromFailable(() => JSON.parse(s)).flatMap((eitherPipelineJson) => isPipeline(eitherPipelineJson) ? import_pengueno2.Either.right(eitherPipelineJson) : import_pengueno2.Either.left(new Error("oh noes D: its a bad pipewine :(("))).mapRight((pipeline) => new _PipelineImpl(pipeline.serialJobs));
+  }
+};
+
+// node_modules/@emprespresso/ci_model/dist/pipeline/index.js
+var isPipelineStage = (t) => (0, import_pengueno3.isObject)(t) && "parallelJobs" in t && Array.isArray(t.parallelJobs) && t.parallelJobs.every((j) => isJob(j));
+var isPipeline = (t) => (0, import_pengueno3.isObject)(t) && "serialJobs" in t && Array.isArray(t.serialJobs) && t.serialJobs.every((p) => isPipelineStage(p));
+
+// dist/ci.js
+var REGISTRY = "img.liz.coffee";
+var NAMESPACE = "emprespresso";
+var IMG = "rookery";
+var getPipeline = () => {
+  const gitHookPipeline = new DefaultGitHookPipelineBuilder();
+  const branch = gitHookPipeline.getBranch();
+  if (!branch)
+    return gitHookPipeline.build();
+  const build = {
+    type: "build_docker_image.js",
+    arguments: {
+      context: gitHookPipeline.getSourceDestination(),
+      registry: REGISTRY,
+      namespace: NAMESPACE,
+      repository: IMG,
+      imageTag: branch,
+      commit: gitHookPipeline.getRev(),
+      buildTarget: IMG,
+      dockerfile: "Dockerfile"
+    }
+  };
+  gitHookPipeline.addStage({ parallelJobs: [build] });
+  return gitHookPipeline.build();
+};
+var main = () => {
+  const data = getPipeline().serialize();
+  process.stdout.write(data);
+};
+main();
diff --git a/.ci/ci.json b/.ci/ci.json
new file mode 100644
index 0000000..6a51028
--- /dev/null
+++ b/.ci/ci.json
@@ -0,0 +1,3 @@
+{
+    "workflow": ".ci/ci.cjs"
+}
diff --git a/.ci/ci.ts b/.ci/ci.ts
new file mode 100644
index 0000000..7908462
--- /dev/null
+++ b/.ci/ci.ts
@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+import { BuildDockerImageJob, DefaultGitHookPipelineBuilder } from "@emprespresso/ci_model";
+
+const REGISTRY = "img.liz.coffee";
+const NAMESPACE = "emprespresso";
+const IMG = "rookery";
+
+/**
+ * Every push: build the Dockerfile's `rookery` target, which runs the whole test suite
+ * (`gradlew check`) and packages the desktop app. A failing test fails the image build.
+ */
+const getPipeline = () => {
+  const gitHookPipeline = new DefaultGitHookPipelineBuilder();
+  const branch = gitHookPipeline.getBranch();
+  if (!branch) return gitHookPipeline.build();
+
+  const build: BuildDockerImageJob = {
+    type: "build_docker_image.js",
+    arguments: {
+      context: gitHookPipeline.getSourceDestination(),
+      registry: REGISTRY,
+      namespace: NAMESPACE,
+      repository: IMG,
+      imageTag: branch,
+      commit: gitHookPipeline.getRev(),
+      buildTarget: IMG,
+      dockerfile: "Dockerfile",
+    },
+  };
+  gitHookPipeline.addStage({ parallelJobs: [build] });
+
+  return gitHookPipeline.build();
+};
+
+const main = () => {
+  const data = getPipeline().serialize();
+  process.stdout.write(data);
+};
+
+main();
diff --git a/.ci/package-lock.json b/.ci/package-lock.json
new file mode 100644
index 0000000..c6a2ce7
--- /dev/null
+++ b/.ci/package-lock.json
@@ -0,0 +1,920 @@
+{
+    "name": ".ci",
+    "lockfileVersion": 3,
+    "requires": true,
+    "packages": {
+        "": {
+            "dependencies": {
+                "@emprespresso/ci_model": "^0.4.0"
+            },
+            "devDependencies": {
+                "@types/node": "^24.13.3",
+                "esbuild": "0.25.5",
+                "typescript": "^7.0.2"
+            }
+        },
+        "node_modules/@emprespresso/ci_model": {
+            "version": "0.4.0",
+            "resolved": "https://registry.npmjs.org/@emprespresso/ci_model/-/ci_model-0.4.0.tgz",
+            "integrity": "sha512-pdX0LngjzuRtTQLgu1koKjdrAxpBI003XUM6ryVNeCF71tJjEjGAbOGOXoqRjkLgHWWA8uks3rSbk1OrcPFa+A==",
+            "dependencies": {
+                "@emprespresso/pengueno": "^0.0.17"
+            }
+        },
+        "node_modules/@emprespresso/pengueno": {
+            "version": "0.0.17",
+            "resolved": "https://registry.npmjs.org/@emprespresso/pengueno/-/pengueno-0.0.17.tgz",
+            "integrity": "sha512-pyfXLYGoLlQlMQAyYptRLLiRrnQmCju4I1/sv1KtsJv06oPvNqzHqUzJJGHrXg/90krg7GRcxLKQ0TnQ2Bskjw==",
+            "license": "MIT",
+            "engines": {
+                "node": ">=22.16.0",
+                "npm": ">=10.0.0"
+            },
+            "optionalDependencies": {
+                "@hono/node-server": "^1.18.2",
+                "hono": "^4.8.0"
+            }
+        },
+        "node_modules/@esbuild/aix-ppc64": {
+            "version": "0.25.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.5.tgz",
+            "integrity": "sha512-9o3TMmpmftaCMepOdA5k/yDw8SfInyzWWTjYTFCX3kPSDJMROQTb8jg+h9Cnwnmm1vOzvxN7gIfB5V2ewpjtGA==",
+            "cpu": [
+                "ppc64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "aix"
+            ],
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/@esbuild/android-arm": {
+            "version": "0.25.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.5.tgz",
+            "integrity": "sha512-AdJKSPeEHgi7/ZhuIPtcQKr5RQdo6OO2IL87JkianiMYMPbCtot9fxPbrMiBADOWWm3T2si9stAiVsGbTQFkbA==",
+            "cpu": [
+                "arm"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "android"
+            ],
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/@esbuild/android-arm64": {
+            "version": "0.25.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.5.tgz",
+            "integrity": "sha512-VGzGhj4lJO+TVGV1v8ntCZWJktV7SGCs3Pn1GRWI1SBFtRALoomm8k5E9Pmwg3HOAal2VDc2F9+PM/rEY6oIDg==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "android"
+            ],
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/@esbuild/android-x64": {
+            "version": "0.25.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.5.tgz",
+            "integrity": "sha512-D2GyJT1kjvO//drbRT3Hib9XPwQeWd9vZoBJn+bu/lVsOZ13cqNdDeqIF/xQ5/VmWvMduP6AmXvylO/PIc2isw==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "android"
+            ],
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/@esbuild/darwin-arm64": {
+            "version": "0.25.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.5.tgz",
+            "integrity": "sha512-GtaBgammVvdF7aPIgH2jxMDdivezgFu6iKpmT+48+F8Hhg5J/sfnDieg0aeG/jfSvkYQU2/pceFPDKlqZzwnfQ==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "darwin"
+            ],
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/@esbuild/darwin-x64": {
+            "version": "0.25.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.5.tgz",
+            "integrity": "sha512-1iT4FVL0dJ76/q1wd7XDsXrSW+oLoquptvh4CLR4kITDtqi2e/xwXwdCVH8hVHU43wgJdsq7Gxuzcs6Iq/7bxQ==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "darwin"
+            ],
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/@esbuild/freebsd-arm64": {
+            "version": "0.25.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.5.tgz",
+            "integrity": "sha512-nk4tGP3JThz4La38Uy/gzyXtpkPW8zSAmoUhK9xKKXdBCzKODMc2adkB2+8om9BDYugz+uGV7sLmpTYzvmz6Sw==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "freebsd"
+            ],
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/@esbuild/freebsd-x64": {
+            "version": "0.25.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.5.tgz",
+            "integrity": "sha512-PrikaNjiXdR2laW6OIjlbeuCPrPaAl0IwPIaRv+SMV8CiM8i2LqVUHFC1+8eORgWyY7yhQY+2U2fA55mBzReaw==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "freebsd"
+            ],
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/@esbuild/linux-arm": {
+            "version": "0.25.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.5.tgz",
+            "integrity": "sha512-cPzojwW2okgh7ZlRpcBEtsX7WBuqbLrNXqLU89GxWbNt6uIg78ET82qifUy3W6OVww6ZWobWub5oqZOVtwolfw==",
+            "cpu": [
+                "arm"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ],
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/@esbuild/linux-arm64": {
+            "version": "0.25.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.5.tgz",
+            "integrity": "sha512-Z9kfb1v6ZlGbWj8EJk9T6czVEjjq2ntSYLY2cw6pAZl4oKtfgQuS4HOq41M/BcoLPzrUbNd+R4BXFyH//nHxVg==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ],
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/@esbuild/linux-ia32": {
+            "version": "0.25.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.5.tgz",
+            "integrity": "sha512-sQ7l00M8bSv36GLV95BVAdhJ2QsIbCuCjh/uYrWiMQSUuV+LpXwIqhgJDcvMTj+VsQmqAHL2yYaasENvJ7CDKA==",
+            "cpu": [
+                "ia32"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ],
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/@esbuild/linux-loong64": {
+            "version": "0.25.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.5.tgz",
+            "integrity": "sha512-0ur7ae16hDUC4OL5iEnDb0tZHDxYmuQyhKhsPBV8f99f6Z9KQM02g33f93rNH5A30agMS46u2HP6qTdEt6Q1kg==",
+            "cpu": [
+                "loong64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ],
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/@esbuild/linux-mips64el": {
+            "version": "0.25.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.5.tgz",
+            "integrity": "sha512-kB/66P1OsHO5zLz0i6X0RxlQ+3cu0mkxS3TKFvkb5lin6uwZ/ttOkP3Z8lfR9mJOBk14ZwZ9182SIIWFGNmqmg==",
+            "cpu": [
+                "mips64el"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ],
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/@esbuild/linux-ppc64": {
+            "version": "0.25.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.5.tgz",
+            "integrity": "sha512-UZCmJ7r9X2fe2D6jBmkLBMQetXPXIsZjQJCjgwpVDz+YMcS6oFR27alkgGv3Oqkv07bxdvw7fyB71/olceJhkQ==",
+            "cpu": [
+                "ppc64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ],
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/@esbuild/linux-riscv64": {
+            "version": "0.25.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.5.tgz",
+            "integrity": "sha512-kTxwu4mLyeOlsVIFPfQo+fQJAV9mh24xL+y+Bm6ej067sYANjyEw1dNHmvoqxJUCMnkBdKpvOn0Ahql6+4VyeA==",
+            "cpu": [
+                "riscv64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ],
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/@esbuild/linux-s390x": {
+            "version": "0.25.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.5.tgz",
+            "integrity": "sha512-K2dSKTKfmdh78uJ3NcWFiqyRrimfdinS5ErLSn3vluHNeHVnBAFWC8a4X5N+7FgVE1EjXS1QDZbpqZBjfrqMTQ==",
+            "cpu": [
+                "s390x"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ],
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/@esbuild/linux-x64": {
+            "version": "0.25.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.5.tgz",
+            "integrity": "sha512-uhj8N2obKTE6pSZ+aMUbqq+1nXxNjZIIjCjGLfsWvVpy7gKCOL6rsY1MhRh9zLtUtAI7vpgLMK6DxjO8Qm9lJw==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ],
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/@esbuild/netbsd-arm64": {
+            "version": "0.25.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.5.tgz",
+            "integrity": "sha512-pwHtMP9viAy1oHPvgxtOv+OkduK5ugofNTVDilIzBLpoWAM16r7b/mxBvfpuQDpRQFMfuVr5aLcn4yveGvBZvw==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "netbsd"
+            ],
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/@esbuild/netbsd-x64": {
+            "version": "0.25.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.5.tgz",
+            "integrity": "sha512-WOb5fKrvVTRMfWFNCroYWWklbnXH0Q5rZppjq0vQIdlsQKuw6mdSihwSo4RV/YdQ5UCKKvBy7/0ZZYLBZKIbwQ==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "netbsd"
+            ],
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/@esbuild/openbsd-arm64": {
+            "version": "0.25.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.5.tgz",
+            "integrity": "sha512-7A208+uQKgTxHd0G0uqZO8UjK2R0DDb4fDmERtARjSHWxqMTye4Erz4zZafx7Di9Cv+lNHYuncAkiGFySoD+Mw==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "openbsd"
+            ],
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/@esbuild/openbsd-x64": {
+            "version": "0.25.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.5.tgz",
+            "integrity": "sha512-G4hE405ErTWraiZ8UiSoesH8DaCsMm0Cay4fsFWOOUcz8b8rC6uCvnagr+gnioEjWn0wC+o1/TAHt+It+MpIMg==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "openbsd"
+            ],
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/@esbuild/sunos-x64": {
+            "version": "0.25.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.5.tgz",
+            "integrity": "sha512-l+azKShMy7FxzY0Rj4RCt5VD/q8mG/e+mDivgspo+yL8zW7qEwctQ6YqKX34DTEleFAvCIUviCFX1SDZRSyMQA==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "sunos"
+            ],
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/@esbuild/win32-arm64": {
+            "version": "0.25.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.5.tgz",
+            "integrity": "sha512-O2S7SNZzdcFG7eFKgvwUEZ2VG9D/sn/eIiz8XRZ1Q/DO5a3s76Xv0mdBzVM5j5R639lXQmPmSo0iRpHqUUrsxw==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "win32"
+            ],
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/@esbuild/win32-ia32": {
+            "version": "0.25.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.5.tgz",
+            "integrity": "sha512-onOJ02pqs9h1iMJ1PQphR+VZv8qBMQ77Klcsqv9CNW2w6yLqoURLcgERAIurY6QE63bbLuqgP9ATqajFLK5AMQ==",
+            "cpu": [
+                "ia32"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "win32"
+            ],
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/@esbuild/win32-x64": {
+            "version": "0.25.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.5.tgz",
+            "integrity": "sha512-TXv6YnJ8ZMVdX+SXWVBo/0p8LTcrUYngpWjvm91TMjjBQii7Oz11Lw5lbDV5Y0TzuhSJHwiH4hEtC1I42mMS0g==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "win32"
+            ],
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/@hono/node-server": {
+            "version": "1.19.19",
+            "resolved": "https://registry.npmjs.org/@hono/node-server/-/node-server-1.19.19.tgz",
+            "integrity": "sha512-Fy9R7PACOzHU9LDpfnuzVyuVYevKQRcEG2mZhmfc+DRdmayEd3RVfa2XOt2IgGcPNgA77Yk63KBszepcMFK5Ng==",
+            "license": "MIT",
+            "optional": true,
+            "engines": {
+                "node": ">=18.14.1"
+            },
+            "peerDependencies": {
+                "hono": "^4"
+            }
+        },
+        "node_modules/@types/node": {
+            "version": "24.19.2",
+            "resolved": "https://registry.npmjs.org/@types/node/-/node-24.19.2.tgz",
+            "integrity": "sha512-93d49wCWJkCyN87MxLpNN6KXPCwFw7bVUg79mGUV1OS40JGWwVCr8n61DXCSqz7CV6/VfPkb7xec7uP2M+QHWQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "undici-types": ">=7.24.0 <7.24.7"
+            }
+        },
+        "node_modules/@typescript/typescript-aix-ppc64": {
+            "version": "7.0.2",
+            "resolved": "https://registry.npmjs.org/@typescript/typescript-aix-ppc64/-/typescript-aix-ppc64-7.0.2.tgz",
+            "integrity": "sha512-MTKKkWB7p/0E9xi1d1tHtZ5PiLkGEMIq88pK2CubZjOsLtYTLqhgIgi6zepFa+9GHZ6h05NMCkQxGKiPXMxXtQ==",
+            "cpu": [
+                "ppc64"
+            ],
+            "dev": true,
+            "license": "Apache-2.0",
+            "optional": true,
+            "os": [
+                "aix"
+            ],
+            "engines": {
+                "node": ">=16.20.0"
+            }
+        },
+        "node_modules/@typescript/typescript-darwin-arm64": {
+            "version": "7.0.2",
+            "resolved": "https://registry.npmjs.org/@typescript/typescript-darwin-arm64/-/typescript-darwin-arm64-7.0.2.tgz",
+            "integrity": "sha512-gowzar9MwS/aRWp6f3a4KUqzRjAZjOsmGNCM6LcTgXum+dBfgsBVMN+AgvOCCbguXyick6LJhpBszxMebJ8syA==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "Apache-2.0",
+            "optional": true,
+            "os": [
+                "darwin"
+            ],
+            "engines": {
+                "node": ">=16.20.0"
+            }
+        },
+        "node_modules/@typescript/typescript-darwin-x64": {
+            "version": "7.0.2",
+            "resolved": "https://registry.npmjs.org/@typescript/typescript-darwin-x64/-/typescript-darwin-x64-7.0.2.tgz",
+            "integrity": "sha512-SZ9xZInqApNlNGc9s0W1VSsktYSOe9cFqNOIqmN1Gs8SmkjKZYFt017G4VwPxASInODuAdbTW7sXiFUf893RgA==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "Apache-2.0",
+            "optional": true,
+            "os": [
+                "darwin"
+            ],
+            "engines": {
+                "node": ">=16.20.0"
+            }
+        },
+        "node_modules/@typescript/typescript-freebsd-arm64": {
+            "version": "7.0.2",
+            "resolved": "https://registry.npmjs.org/@typescript/typescript-freebsd-arm64/-/typescript-freebsd-arm64-7.0.2.tgz",
+            "integrity": "sha512-W5NH4y/J0plIIS5b2xvTEkU7JFxyqdMAOgf+Ilhl0vHQXKO5dZoxd+C/jEtq56c4F3wk71RB4BMRQ2XdI+bwYQ==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "Apache-2.0",
+            "optional": true,
+            "os": [
+                "freebsd"
+            ],
+            "engines": {
+                "node": ">=16.20.0"
+            }
+        },
+        "node_modules/@typescript/typescript-freebsd-x64": {
+            "version": "7.0.2",
+            "resolved": "https://registry.npmjs.org/@typescript/typescript-freebsd-x64/-/typescript-freebsd-x64-7.0.2.tgz",
+            "integrity": "sha512-UMGDx5sTpzNw3WiPebH7l90IWfJggEd+egHt/q6p7/Cm3zqoV7VxkGXt+3DxPIw8CcmvAB0j3sVVfbhX+M4Tpw==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "Apache-2.0",
+            "optional": true,
+            "os": [
+                "freebsd"
+            ],
+            "engines": {
+                "node": ">=16.20.0"
+            }
+        },
+        "node_modules/@typescript/typescript-linux-arm": {
+            "version": "7.0.2",
+            "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-arm/-/typescript-linux-arm-7.0.2.tgz",
+            "integrity": "sha512-gffT3xPz9sR7j/YJExkyPntrI0P2EP9XbOyWzth2/Gs0RstK+90RBcO0ncXoXy/beYll1SXw846Nf2zdnEz0QQ==",
+            "cpu": [
+                "arm"
+            ],
+            "dev": true,
+            "license": "Apache-2.0",
+            "optional": true,
+            "os": [
+                "linux"
+            ],
+            "engines": {
+                "node": ">=16.20.0"
+            }
+        },
+        "node_modules/@typescript/typescript-linux-arm64": {
+            "version": "7.0.2",
+            "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-arm64/-/typescript-linux-arm64-7.0.2.tgz",
+            "integrity": "sha512-Qh4eU4/y3yDjnfjjyPYihMj5/ODIlmt+Bzu17OI+fiSRDW57QmU5SiN63exPRNJPKUzcc1INa1NXdrJ+MqHjUQ==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "Apache-2.0",
+            "optional": true,
+            "os": [
+                "linux"
+            ],
+            "engines": {
+                "node": ">=16.20.0"
+            }
+        },
+        "node_modules/@typescript/typescript-linux-loong64": {
+            "version": "7.0.2",
+            "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-loong64/-/typescript-linux-loong64-7.0.2.tgz",
+            "integrity": "sha512-uEHck9i8hoAzXPiYRib1O7miOnz23SxIeVl6F4LXox+qov1K35jHcEW6VHKvZI+pyvl7fZEP4MCU5LYvIq1GuQ==",
+            "cpu": [
+                "loong64"
+            ],
+            "dev": true,
+            "license": "Apache-2.0",
+            "optional": true,
+            "os": [
+                "linux"
+            ],
+            "engines": {
+                "node": ">=16.20.0"
+            }
+        },
+        "node_modules/@typescript/typescript-linux-mips64el": {
+            "version": "7.0.2",
+            "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-mips64el/-/typescript-linux-mips64el-7.0.2.tgz",
+            "integrity": "sha512-R4KvAMnE43W5Qeqb0Ly56O3mWMWIAgsMyz36DCaycd5nbg/9kzm0liw3JocfRqyJY0KPmzFjbswozXyW0DnIYA==",
+            "cpu": [
+                "mips64el"
+            ],
+            "dev": true,
+            "license": "Apache-2.0",
+            "optional": true,
+            "os": [
+                "linux"
+            ],
+            "engines": {
+                "node": ">=16.20.0"
+            }
+        },
+        "node_modules/@typescript/typescript-linux-ppc64": {
+            "version": "7.0.2",
+            "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-ppc64/-/typescript-linux-ppc64-7.0.2.tgz",
+            "integrity": "sha512-DORx5b3sd/4S7eayxm4FQv+A7CrkUIGRaHiwI8oiHTAI1fAPWhF4J0vAlkC8biAlHSVVwxMQ3tjZ2/DVbnQiiA==",
+            "cpu": [
+                "ppc64"
+            ],
+            "dev": true,
+            "license": "Apache-2.0",
+            "optional": true,
+            "os": [
+                "linux"
+            ],
+            "engines": {
+                "node": ">=16.20.0"
+            }
+        },
+        "node_modules/@typescript/typescript-linux-riscv64": {
+            "version": "7.0.2",
+            "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-riscv64/-/typescript-linux-riscv64-7.0.2.tgz",
+            "integrity": "sha512-wf0jqEDOjrPRnKwYRyyJDRo11KMbvMFrU+q4zqKyChODBzvlkbhNQfKvLxQCcwTpdDaXSHZTVuh0JoCrKCUMHQ==",
+            "cpu": [
+                "riscv64"
+            ],
+            "dev": true,
+            "license": "Apache-2.0",
+            "optional": true,
+            "os": [
+                "linux"
+            ],
+            "engines": {
+                "node": ">=16.20.0"
+            }
+        },
+        "node_modules/@typescript/typescript-linux-s390x": {
+            "version": "7.0.2",
+            "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-s390x/-/typescript-linux-s390x-7.0.2.tgz",
+            "integrity": "sha512-IkwJc3L7yhytWd/ewjyxNDfOmswCm9GWMJT/ue/dU4aZNbwZeYAetq42VyLmsmSjvoX7z74X6ZaYCtzAr0EuGw==",
+            "cpu": [
+                "s390x"
+            ],
+            "dev": true,
+            "license": "Apache-2.0",
+            "optional": true,
+            "os": [
+                "linux"
+            ],
+            "engines": {
+                "node": ">=16.20.0"
+            }
+        },
+        "node_modules/@typescript/typescript-linux-x64": {
+            "version": "7.0.2",
+            "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-x64/-/typescript-linux-x64-7.0.2.tgz",
+            "integrity": "sha512-EYdf2cNg7rgCWJnxCdJ+F3V39O8ihb37eHAu1LK8oAFizgTQbPOK7zHHXbPt8rX24COqODXeI3sIf0fCXG7H/A==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "Apache-2.0",
+            "optional": true,
+            "os": [
+                "linux"
+            ],
+            "engines": {
+                "node": ">=16.20.0"
+            }
+        },
+        "node_modules/@typescript/typescript-netbsd-arm64": {
+            "version": "7.0.2",
+            "resolved": "https://registry.npmjs.org/@typescript/typescript-netbsd-arm64/-/typescript-netbsd-arm64-7.0.2.tgz",
+            "integrity": "sha512-+polYF4MF04aPpO5FTkHran9yUQDSXqy5GiSDKpsll5jy3l3+g9QLhpf39T+ePtefhXLOGrLl0QIjkQP6VnelA==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "Apache-2.0",
+            "optional": true,
+            "os": [
+                "netbsd"
+            ],
+            "engines": {
+                "node": ">=16.20.0"
+            }
+        },
+        "node_modules/@typescript/typescript-netbsd-x64": {
+            "version": "7.0.2",
+            "resolved": "https://registry.npmjs.org/@typescript/typescript-netbsd-x64/-/typescript-netbsd-x64-7.0.2.tgz",
+            "integrity": "sha512-8YIT0EHM/3dq10ZOVF/A7pc/YSMtbcecct4rWtexrnSCHOPcpC2KTLXfTCR6vDpnSiY12heNb1GiN/wu+T/FyA==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "Apache-2.0",
+            "optional": true,
+            "os": [
+                "netbsd"
+            ],
+            "engines": {
+                "node": ">=16.20.0"
+            }
+        },
+        "node_modules/@typescript/typescript-openbsd-arm64": {
+            "version": "7.0.2",
+            "resolved": "https://registry.npmjs.org/@typescript/typescript-openbsd-arm64/-/typescript-openbsd-arm64-7.0.2.tgz",
+            "integrity": "sha512-APT8+ClYnuYm1u9+kgGXoMj2VzWzcymwh2gNSQVySHfkRDGOTVkoWLjCmOQSaO+PoqQ57B0flRp9SA+7GnnkzQ==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "Apache-2.0",
+            "optional": true,
+            "os": [
+                "openbsd"
+            ],
+            "engines": {
+                "node": ">=16.20.0"
+            }
+        },
+        "node_modules/@typescript/typescript-openbsd-x64": {
+            "version": "7.0.2",
+            "resolved": "https://registry.npmjs.org/@typescript/typescript-openbsd-x64/-/typescript-openbsd-x64-7.0.2.tgz",
+            "integrity": "sha512-yX7s+Q0Dln0Dt9tEzZsAjXXR/+ytBM7AlglaqyeMPxQszJ1JhlJdZ6jLA+IzldHtflX81em7lDao1xXu+aRRkg==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "Apache-2.0",
+            "optional": true,
+            "os": [
+                "openbsd"
+            ],
+            "engines": {
+                "node": ">=16.20.0"
+            }
+        },
+        "node_modules/@typescript/typescript-sunos-x64": {
+            "version": "7.0.2",
+            "resolved": "https://registry.npmjs.org/@typescript/typescript-sunos-x64/-/typescript-sunos-x64-7.0.2.tgz",
+            "integrity": "sha512-dLJDGaLZ1D4HPQn62u1n8mBDkJREwMsAkCdkwd4Ieqw+x3TUyTsqY0YiBCtE6H6OzzgGk3iuZ3vFWRS+E8/d1g==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "Apache-2.0",
+            "optional": true,
+            "os": [
+                "sunos"
+            ],
+            "engines": {
+                "node": ">=16.20.0"
+            }
+        },
+        "node_modules/@typescript/typescript-win32-arm64": {
+            "version": "7.0.2",
+            "resolved": "https://registry.npmjs.org/@typescript/typescript-win32-arm64/-/typescript-win32-arm64-7.0.2.tgz",
+            "integrity": "sha512-Gyl1Vy6OsWesLzmq+EP0Fb7b4Nid5232AvcA2SFcdYreldpNtYFFofPjnt62y9hQy7VTaZp65ICJjuAQRaVcIQ==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "Apache-2.0",
+            "optional": true,
+            "os": [
+                "win32"
+            ],
+            "engines": {
+                "node": ">=16.20.0"
+            }
+        },
+        "node_modules/@typescript/typescript-win32-x64": {
+            "version": "7.0.2",
+            "resolved": "https://registry.npmjs.org/@typescript/typescript-win32-x64/-/typescript-win32-x64-7.0.2.tgz",
+            "integrity": "sha512-0BQ3HkAHHlKLSp1qRvf3SUhGpGsDuhB/jgFw75guyqbxJqEaS0Cw/VFO8i2nHglJUzQCRtMMR/IBAKE3ETMC4g==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "Apache-2.0",
+            "optional": true,
+            "os": [
+                "win32"
+            ],
+            "engines": {
+                "node": ">=16.20.0"
+            }
+        },
+        "node_modules/esbuild": {
+            "version": "0.25.5",
+            "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.5.tgz",
+            "integrity": "sha512-P8OtKZRv/5J5hhz0cUAdu/cLuPIKXpQl1R9pZtvmHWQvrAUVd0UNIPT4IB4W3rNOqVO0rlqHmCIbSwxh/c9yUQ==",
+            "dev": true,
+            "hasInstallScript": true,
+            "license": "MIT",
+            "bin": {
+                "esbuild": "bin/esbuild"
+            },
+            "engines": {
+                "node": ">=18"
+            },
+            "optionalDependencies": {
+                "@esbuild/aix-ppc64": "0.25.5",
+                "@esbuild/android-arm": "0.25.5",
+                "@esbuild/android-arm64": "0.25.5",
+                "@esbuild/android-x64": "0.25.5",
+                "@esbuild/darwin-arm64": "0.25.5",
+                "@esbuild/darwin-x64": "0.25.5",
+                "@esbuild/freebsd-arm64": "0.25.5",
+                "@esbuild/freebsd-x64": "0.25.5",
+                "@esbuild/linux-arm": "0.25.5",
+                "@esbuild/linux-arm64": "0.25.5",
+                "@esbuild/linux-ia32": "0.25.5",
+                "@esbuild/linux-loong64": "0.25.5",
+                "@esbuild/linux-mips64el": "0.25.5",
+                "@esbuild/linux-ppc64": "0.25.5",
+                "@esbuild/linux-riscv64": "0.25.5",
+                "@esbuild/linux-s390x": "0.25.5",
+                "@esbuild/linux-x64": "0.25.5",
+                "@esbuild/netbsd-arm64": "0.25.5",
+                "@esbuild/netbsd-x64": "0.25.5",
+                "@esbuild/openbsd-arm64": "0.25.5",
+                "@esbuild/openbsd-x64": "0.25.5",
+                "@esbuild/sunos-x64": "0.25.5",
+                "@esbuild/win32-arm64": "0.25.5",
+                "@esbuild/win32-ia32": "0.25.5",
+                "@esbuild/win32-x64": "0.25.5"
+            }
+        },
+        "node_modules/hono": {
+            "version": "4.13.18",
+            "resolved": "https://registry.npmjs.org/hono/-/hono-4.13.18.tgz",
+            "integrity": "sha512-H9q/E1XizaWstJxUW881dmLxEj+t/TrGGnyxINkm4+sK0qUwsMtFdo2BWI9Vs3cIS19MU6b6iCijoUoEf4f3DA==",
+            "license": "MIT",
+            "optional": true,
+            "engines": {
+                "node": ">=16.9.0"
+            }
+        },
+        "node_modules/typescript": {
+            "version": "7.0.2",
+            "resolved": "https://registry.npmjs.org/typescript/-/typescript-7.0.2.tgz",
+            "integrity": "sha512-8FYau96o3NKOhbjKi/qNvG/W5jhzxkbdm5sj9AbZ/5T5sWqn3hJgLfGx27sRKZWTvyzCP8dLRBTf5tBTSRVUNA==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "bin": {
+                "tsc": "bin/tsc"
+            },
+            "engines": {
+                "node": ">=16.20.0"
+            },
+            "optionalDependencies": {
+                "@typescript/typescript-aix-ppc64": "7.0.2",
+                "@typescript/typescript-darwin-arm64": "7.0.2",
+                "@typescript/typescript-darwin-x64": "7.0.2",
+                "@typescript/typescript-freebsd-arm64": "7.0.2",
+                "@typescript/typescript-freebsd-x64": "7.0.2",
+                "@typescript/typescript-linux-arm": "7.0.2",
+                "@typescript/typescript-linux-arm64": "7.0.2",
+                "@typescript/typescript-linux-loong64": "7.0.2",
+                "@typescript/typescript-linux-mips64el": "7.0.2",
+                "@typescript/typescript-linux-ppc64": "7.0.2",
+                "@typescript/typescript-linux-riscv64": "7.0.2",
+                "@typescript/typescript-linux-s390x": "7.0.2",
+                "@typescript/typescript-linux-x64": "7.0.2",
+                "@typescript/typescript-netbsd-arm64": "7.0.2",
+                "@typescript/typescript-netbsd-x64": "7.0.2",
+                "@typescript/typescript-openbsd-arm64": "7.0.2",
+                "@typescript/typescript-openbsd-x64": "7.0.2",
+                "@typescript/typescript-sunos-x64": "7.0.2",
+                "@typescript/typescript-win32-arm64": "7.0.2",
+                "@typescript/typescript-win32-x64": "7.0.2"
+            }
+        },
+        "node_modules/undici-types": {
+            "version": "7.24.6",
+            "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.24.6.tgz",
+            "integrity": "sha512-WRNW+sJgj5OBN4/0JpHFqtqzhpbnV0GuB+OozA9gCL7a993SmU+1JBZCzLNxYsbMfIeDL+lTsphD5jN5N+n0zg==",
+            "dev": true,
+            "license": "MIT"
+        }
+    }
+}
diff --git a/.ci/package.json b/.ci/package.json
new file mode 100644
index 0000000..e71148e
--- /dev/null
+++ b/.ci/package.json
@@ -0,0 +1,18 @@
+{
+    "scripts": {
+        "build": "tsc && esbuild --format=cjs --target=node22 --platform=node --bundle --outfile=ci.cjs dist/ci.js && chmod +x ci.cjs",
+        "clean": "rm -rf dist ci.cjs"
+    },
+    "dependencies": {
+        "@emprespresso/ci_model": "^0.4.0"
+    },
+    "devDependencies": {
+        "@types/node": "^24.13.3",
+        "esbuild": "0.25.5",
+        "typescript": "^7.0.2"
+    },
+    "files": [
+        "dist/**/*",
+        "package.json"
+    ]
+}
diff --git a/.ci/tsconfig.json b/.ci/tsconfig.json
new file mode 100644
index 0000000..6e44f85
--- /dev/null
+++ b/.ci/tsconfig.json
@@ -0,0 +1,28 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "ESNext",
+        "lib": ["ES2022"],
+        "outDir": "./dist",
+        "rootDir": "./",
+        "composite": true,
+        "declaration": true,
+        "declarationMap": true,
+        "sourceMap": true,
+        "noEmit": false,
+        "strict": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "allowSyntheticDefaultImports": true,
+        "esModuleInterop": true,
+        "resolveJsonModule": true,
+        "isolatedModules": true,
+        "noUncheckedIndexedAccess": true,
+        "exactOptionalPropertyTypes": true,
+        "noImplicitReturns": true,
+        "noFallthroughCasesInSwitch": true,
+        "types": ["node"]
+    },
+    "include": ["**/*.ts"],
+    "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts"]
+}
diff --git a/.dockerignore b/.dockerignore
new file mode 100644
index 0000000..d02da12
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1,6 @@
+.git
+.gradle
+.kotlin
+**/build
+.ci/node_modules
+.ci/dist
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..f70c7a8
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,6 @@
+.gradle/
+build/
+.kotlin/
+.idea/
+*.iml
+local.properties
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000..b65f8e2
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,19 @@
+# Build + test stage: a failing test fails the image build, which is what lizCI checks.
+FROM eclipse-temurin:21-jdk AS build
+WORKDIR /src
+# Warm the Gradle wrapper and dependency cache before copying sources.
+COPY gradlew settings.gradle.kts build.gradle.kts gradle.properties ./
+COPY gradle gradle
+COPY core/build.gradle.kts core/
+COPY ui/build.gradle.kts ui/
+COPY desktop/build.gradle.kts desktop/
+RUN ./gradlew --no-daemon -q help
+COPY . .
+RUN ./gradlew --no-daemon check :desktop:createDistributable
+
+# Artifact image: just the packaged Linux desktop app (with its bundled runtime).
+FROM alpine:3.20 AS rookery
+ARG COMMIT=unknown
+COPY --from=build /src/desktop/build/compose/binaries/main/app/rookery /opt/rookery
+RUN printf '%s' "$COMMIT" > /opt/rookery/commit
+CMD ["ls", "/opt/rookery"]
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..50433c3
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 the rookery authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/build.gradle.kts b/build.gradle.kts
new file mode 100644
index 0000000..1efb0bc
--- /dev/null
+++ b/build.gradle.kts
@@ -0,0 +1,7 @@
+plugins {
+    alias(libs.plugins.kotlin.multiplatform) apply false
+    alias(libs.plugins.kotlin.jvm) apply false
+    alias(libs.plugins.kotlin.serialization) apply false
+    alias(libs.plugins.kotlin.compose) apply false
+    alias(libs.plugins.compose) apply false
+}
diff --git a/core/build.gradle.kts b/core/build.gradle.kts
new file mode 100644
index 0000000..718fdaa
--- /dev/null
+++ b/core/build.gradle.kts
@@ -0,0 +1,28 @@
+plugins {
+    alias(libs.plugins.kotlin.multiplatform)
+    alias(libs.plugins.kotlin.serialization)
+}
+
+kotlin {
+    jvmToolchain(21)
+    jvm()
+
+    sourceSets {
+        commonMain.dependencies {
+            implementation(libs.coroutines.core)
+            api(libs.serialization.json)
+        }
+        commonTest.dependencies {
+            implementation(kotlin("test"))
+            implementation(libs.coroutines.test)
+        }
+        jvmMain.dependencies {
+            implementation(libs.tnoodle.scrambles)
+            implementation(libs.dbus.java.core)
+            implementation(libs.dbus.java.transport.native)
+        }
+    }
+}
+
+// Same heap cap as the desktop app, so tests catch scramblers that outgrow it.
+tasks.withType<Test>().configureEach { maxHeapSize = "256m" }
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/Platform.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/Platform.kt
new file mode 100644
index 0000000..954e423
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/Platform.kt
@@ -0,0 +1,13 @@
+package coffee.liz.rookery
+
+/** Wall-clock time in Unix epoch milliseconds. */
+expect fun epochMillis(): Long
+
+/** Monotonic milliseconds for measuring durations; never goes backwards. */
+expect fun monoMillis(): Long
+
+/** A random identifier, unique enough to name devices and new entities. */
+expect fun randomId(): String
+
+/** Mutual exclusion on [lock] (reentrant). */
+expect fun <T> locked(lock: Any, block: () -> T): T
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/audio/Chime.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/audio/Chime.kt
new file mode 100644
index 0000000..6fe59f9
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/audio/Chime.kt
@@ -0,0 +1,69 @@
+package coffee.liz.rookery.audio
+
+import kotlin.math.PI
+import kotlin.math.exp
+import kotlin.math.pow
+import kotlin.math.sin
+
+/**
+ * A tiny 8-bit synth: pulse and triangle voices with a plucky envelope, rendered to 16-bit mono PCM.
+ * Generated in code so there's no audio asset to ship or license.
+ */
+object Chime {
+    const val SAMPLE_RATE = 44_100
+
+    enum class Voice { PULSE25, PULSE50, TRIANGLE }
+
+    /** A note: MIDI pitch (null = rest), start and length in sixteenth notes. */
+    data class Note(val midi: Int?, val start: Int, val len: Int, val voice: Voice = Voice.PULSE25, val vol: Double = 0.5)
+
+    /** The single-PB jingle: a rising arpeggio and a sparkly resolution. */
+    val PB = listOf(
+        Note(72, 0, 1), Note(76, 1, 1), Note(79, 2, 1), Note(84, 3, 3, Voice.PULSE50),
+        Note(83, 6, 1), Note(84, 7, 4, Voice.PULSE50),
+        Note(48, 0, 3, Voice.TRIANGLE, 0.6), Note(55, 3, 3, Voice.TRIANGLE, 0.6), Note(60, 6, 5, Voice.TRIANGLE, 0.6),
+        Note(91, 8, 1, Voice.PULSE25, 0.25), Note(96, 9, 2, Voice.PULSE25, 0.2),
+    )
+
+    /** Longer fanfare for average PBs. */
+    val AVERAGE_PB = listOf(
+        Note(67, 0, 1), Note(72, 1, 1), Note(76, 2, 1), Note(79, 3, 2),
+        Note(76, 5, 1), Note(79, 6, 4, Voice.PULSE50),
+        Note(77, 10, 1), Note(81, 11, 1), Note(84, 12, 1), Note(89, 13, 5, Voice.PULSE50),
+        Note(43, 0, 5, Voice.TRIANGLE, 0.6), Note(48, 5, 5, Voice.TRIANGLE, 0.6), Note(53, 10, 3, Voice.TRIANGLE, 0.6), Note(48, 13, 5, Voice.TRIANGLE, 0.6),
+        Note(96, 14, 1, Voice.PULSE25, 0.2), Note(100, 15, 1, Voice.PULSE25, 0.2), Note(103, 16, 2, Voice.PULSE25, 0.2),
+    )
+
+    /** Short descending blip for a DNF. */
+    val DNF = listOf(Note(64, 0, 1, Voice.PULSE50, 0.35), Note(57, 1, 2, Voice.PULSE50, 0.35))
+
+    fun render(notes: List<Note>, bpm: Int = 150, volume: Double = 0.35): ShortArray {
+        val sixteenth = SAMPLE_RATE * 60.0 / bpm / 4
+        val total = ((notes.maxOf { it.start + it.len } + 2) * sixteenth).toInt()
+        val mix = DoubleArray(total)
+        for (note in notes) {
+            val midi = note.midi ?: continue
+            val freq = 440.0 * 2.0.pow((midi - 69) / 12.0)
+            val start = (note.start * sixteenth).toInt()
+            val len = (note.len * sixteenth).toInt()
+            val release = (0.04 * SAMPLE_RATE).toInt()
+            for (i in 0 until len + release) {
+                val idx = start + i
+                if (idx >= total) break
+                val phase = (i * freq / SAMPLE_RATE) % 1.0
+                val wave = when (note.voice) {
+                    Voice.PULSE25 -> if (phase < 0.25) 1.0 else -1.0
+                    Voice.PULSE50 -> if (phase < 0.5) 1.0 else -1.0
+                    Voice.TRIANGLE -> 4 * kotlin.math.abs(phase - 0.5) - 1
+                }
+                val attack = minOf(1.0, i / (0.004 * SAMPLE_RATE))
+                val decay = exp(-i / (len * 0.9 + 1))
+                val tail = if (i < len) 1.0 else 1.0 - (i - len).toDouble() / release
+                // a dash of vibrato on long notes, NES-style
+                val vib = if (i > SAMPLE_RATE / 10) 1 + 0.003 * sin(2 * PI * 6 * i / SAMPLE_RATE) else 1.0
+                mix[idx] += wave * vib * note.vol * attack * (0.35 + 0.65 * decay) * tail
+            }
+        }
+        return ShortArray(total) { i -> (mix[i] * volume * Short.MAX_VALUE).coerceIn(-32767.0, 32767.0).toInt().toShort() }
+    }
+}
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/bt/BleTransport.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/bt/BleTransport.kt
new file mode 100644
index 0000000..7db19a8
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/bt/BleTransport.kt
@@ -0,0 +1,57 @@
+package coffee.liz.rookery.bt
+
+import kotlinx.coroutines.flow.Flow
+
+/**
+ * One advertisement / discovery result. [manufacturerData] maps company id (16-bit) to its payload.
+ * UUIDs are lower-case 128-bit strings.
+ */
+data class BleAdvertisement(
+    val address: String,
+    val name: String?,
+    val rssi: Int?,
+    val manufacturerData: Map<Int, ByteArray> = emptyMap(),
+    val serviceUuids: List<String> = emptyList(),
+)
+
+data class BleCharacteristic(val uuid: String, val properties: Set<String> = emptySet())
+
+data class BleService(val uuid: String, val characteristics: List<BleCharacteristic>)
+
+/**
+ * Minimal platform-neutral BLE central API (BlueZ on Linux, BluetoothGatt on Android later).
+ * All UUIDs are lower-case 128-bit strings.
+ */
+interface BleTransport {
+    /** Scans until the collector cancels. May emit the same device repeatedly as RSSI updates. */
+    fun scan(): Flow<BleAdvertisement>
+
+    suspend fun connect(address: String): BleConnection
+}
+
+interface BleConnection {
+    val address: String
+    val name: String?
+
+    suspend fun discoverServices(): List<BleService>
+    suspend fun read(service: String, characteristic: String): ByteArray
+    /** Writes a value; the transport picks write-with-response when the characteristic supports it. */
+    suspend fun write(service: String, characteristic: String, value: ByteArray)
+
+    /**
+     * Enables notifications and returns once they are on. Values arriving from then on are buffered
+     * until collected (single collector); the flow completes when the connection closes.
+     */
+    suspend fun subscribe(service: String, characteristic: String): Flow<ByteArray>
+
+    /** Emits once when the link drops, whether by [disconnect] or remotely. */
+    val disconnected: Flow<Unit>
+
+    suspend fun disconnect()
+}
+
+/** Raw AES-128 single-block primitive so the protocol code stays pure common Kotlin. */
+interface Aes128 {
+    fun encryptBlock(key: ByteArray, block: ByteArray): ByteArray
+    fun decryptBlock(key: ByteArray, block: ByteArray): ByteArray
+}
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/bt/GanCrypto.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/bt/GanCrypto.kt
new file mode 100644
index 0000000..a67563e
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/bt/GanCrypto.kt
@@ -0,0 +1,108 @@
+// Protocol details ported from gan-web-bluetooth by Andy Fedotov, MIT License
+// (https://github.com/afedotov/gan-web-bluetooth).
+package coffee.liz.rookery.bt
+
+/** GATT UUIDs and key material for GAN smart cubes. */
+object GanDefinitions {
+    const val GEN2_SERVICE = "6e400001-b5a3-f393-e0a9-e50e24dc4179"
+    const val GEN2_COMMAND = "28be4a4a-cd67-11e9-a32f-2a2ae2dbcce4"
+    const val GEN2_STATE = "28be4cb6-cd67-11e9-a32f-2a2ae2dbcce4"
+
+    const val GEN3_SERVICE = "8653000a-43e6-47b7-9cb0-5fc21d4ae340"
+    const val GEN3_COMMAND = "8653000c-43e6-47b7-9cb0-5fc21d4ae340"
+    const val GEN3_STATE = "8653000b-43e6-47b7-9cb0-5fc21d4ae340"
+
+    const val GEN4_SERVICE = "00000010-0000-fff7-fff6-fff5fff4fff0"
+    const val GEN4_COMMAND = "0000fff5-0000-1000-8000-00805f9b34fb"
+    const val GEN4_STATE = "0000fff6-0000-1000-8000-00805f9b34fb"
+
+    /** Advertised name prefixes of GAN-protocol cubes (MoYu AI 2023 = "AiCube" uses Gen2 with its own key). */
+    val NAME_PREFIXES = listOf("GAN", "MG", "AiCube")
+
+    /** Company identifier codes GAN cubes use: 0x0001, 0x0101, ... 0xFF01. */
+    fun isGanCic(cic: Int): Boolean = (cic and 0xFF) == 0x01
+
+    class KeyIv(val key: ByteArray, val iv: ByteArray)
+
+    private fun bytes(vararg v: Int) = ByteArray(v.size) { v[it].toByte() }
+
+    /** Key used by GAN Gen2, Gen3 and Gen4 cubes. */
+    val GAN_KEY = KeyIv(
+        bytes(0x01, 0x02, 0x42, 0x28, 0x31, 0x91, 0x16, 0x07, 0x20, 0x05, 0x18, 0x54, 0x42, 0x11, 0x12, 0x53),
+        bytes(0x11, 0x03, 0x32, 0x28, 0x21, 0x01, 0x76, 0x27, 0x20, 0x95, 0x78, 0x14, 0x32, 0x12, 0x02, 0x43),
+    )
+
+    /** Key used by MoYu AI 2023 (advertises as "AiCube", speaks GAN Gen2). */
+    val MOYU_AI_KEY = KeyIv(
+        bytes(0x05, 0x12, 0x02, 0x45, 0x02, 0x01, 0x29, 0x56, 0x12, 0x78, 0x12, 0x76, 0x81, 0x01, 0x08, 0x03),
+        bytes(0x01, 0x44, 0x28, 0x06, 0x86, 0x21, 0x22, 0x28, 0x51, 0x05, 0x08, 0x31, 0x82, 0x02, 0x21, 0x06),
+    )
+
+    /** Encryption salt: the 6 MAC bytes in reverse order. Accepts "AA:BB:...", "AA-BB-..." or spaces. */
+    fun saltFromMac(mac: String): ByteArray {
+        val parts = mac.trim().split(Regex("[:\\-\\s]+"))
+        require(parts.size == 6) { "MAC must have 6 bytes: $mac" }
+        return ByteArray(6) { parts[5 - it].toInt(16).toByte() }
+    }
+
+    /**
+     * The cube's MAC from GAN manufacturer-specific data: the last 6 of the first 9 payload bytes, reversed.
+     * Returns null if no GAN company id is present.
+     */
+    fun macFromManufacturerData(data: Map<Int, ByteArray>): String? {
+        val payload = data.entries.firstOrNull { isGanCic(it.key) }?.value ?: return null
+        val view = payload.copyOfRange(0, minOf(9, payload.size))
+        if (view.size < 6) return null
+        return (1..6).joinToString(":") { i -> (view[view.size - i].toInt() and 0xFF).toString(16).uppercase().padStart(2, '0') }
+    }
+}
+
+/**
+ * GAN's message encryption (identical for Gen2/3/4): AES-128-CBC with a fresh IV on each 16-byte chunk,
+ * applied to the chunk at the start of the message and then to the (possibly overlapping) chunk at its end.
+ * Key and IV are salted with the reversed MAC: `k[i] = (k[i] + salt[i]) % 0xFF` for i < 6
+ * (sic: modulo 255, which is what the cube firmware does).
+ */
+class GanEncrypter(private val aes: Aes128, baseKey: ByteArray, baseIv: ByteArray, salt: ByteArray) {
+    val key: ByteArray = baseKey.copyOf()
+    val iv: ByteArray = baseIv.copyOf()
+
+    init {
+        require(baseKey.size == 16) { "Key must be 16 bytes (128-bit) long" }
+        require(baseIv.size == 16) { "Iv must be 16 bytes (128-bit) long" }
+        require(salt.size == 6) { "Salt must be 6 bytes (48-bit) long" }
+        for (i in 0 until 6) {
+            key[i] = (((baseKey[i].toInt() and 0xFF) + (salt[i].toInt() and 0xFF)) % 0xFF).toByte()
+            iv[i] = (((baseIv[i].toInt() and 0xFF) + (salt[i].toInt() and 0xFF)) % 0xFF).toByte()
+        }
+    }
+
+    constructor(aes: Aes128, keyIv: GanDefinitions.KeyIv, mac: String) :
+        this(aes, keyIv.key, keyIv.iv, GanDefinitions.saltFromMac(mac))
+
+    private fun encryptChunk(buf: ByteArray, off: Int) {
+        val block = ByteArray(16) { (buf[off + it].toInt() xor iv[it].toInt()).toByte() }
+        aes.encryptBlock(key, block).copyInto(buf, off)
+    }
+
+    private fun decryptChunk(buf: ByteArray, off: Int) {
+        val plain = aes.decryptBlock(key, buf.copyOfRange(off, off + 16))
+        for (i in 0 until 16) buf[off + i] = (plain[i].toInt() xor iv[i].toInt()).toByte()
+    }
+
+    fun encrypt(data: ByteArray): ByteArray {
+        require(data.size >= 16) { "Data must be at least 16 bytes long" }
+        val res = data.copyOf()
+        encryptChunk(res, 0)
+        if (res.size > 16) encryptChunk(res, res.size - 16)
+        return res
+    }
+
+    fun decrypt(data: ByteArray): ByteArray {
+        require(data.size >= 16) { "Data must be at least 16 bytes long" }
+        val res = data.copyOf()
+        if (res.size > 16) decryptChunk(res, res.size - 16)
+        decryptChunk(res, 0)
+        return res
+    }
+}
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/bt/GanCubeConnector.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/bt/GanCubeConnector.kt
new file mode 100644
index 0000000..c6991d4
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/bt/GanCubeConnector.kt
@@ -0,0 +1,139 @@
+// Protocol details ported from gan-web-bluetooth by Andy Fedotov, MIT License
+// (https://github.com/afedotov/gan-web-bluetooth).
+package coffee.liz.rookery.bt
+
+import coffee.liz.rookery.monoMillis
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.NonCancellable
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.channels.BufferOverflow
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+
+enum class GanGeneration(val service: String, val command: String, val state: String) {
+    GEN2(GanDefinitions.GEN2_SERVICE, GanDefinitions.GEN2_COMMAND, GanDefinitions.GEN2_STATE),
+    GEN3(GanDefinitions.GEN3_SERVICE, GanDefinitions.GEN3_COMMAND, GanDefinitions.GEN3_STATE),
+    GEN4(GanDefinitions.GEN4_SERVICE, GanDefinitions.GEN4_COMMAND, GanDefinitions.GEN4_STATE);
+
+    companion object {
+        fun fromServiceUuids(uuids: Collection<String>): GanGeneration? {
+            val lower = uuids.map { it.lowercase() }.toSet()
+            return entries.firstOrNull { it.service in lower }
+        }
+    }
+}
+
+/** Connects to GAN smart cubes over a [BleTransport]. */
+class GanCubeConnector(
+    private val transport: BleTransport,
+    private val aes: Aes128,
+    private val clock: () -> Long = ::monoMillis,
+) {
+    /**
+     * Connects to [address], detects the protocol generation from its GATT services, turns on notifications
+     * and returns the cube. [mac] (salt for the encryption key) defaults to [address]; pass it explicitly if the
+     * platform exposes a different address than the cube's real MAC. Events are processed in [scope].
+     */
+    suspend fun connect(scope: CoroutineScope, address: String, mac: String = address): SmartCube {
+        val conn = transport.connect(address)
+        try {
+            val services = conn.discoverServices()
+            val gen = GanGeneration.fromServiceUuids(services.map { it.uuid })
+                ?: throw IllegalStateException("No GAN cube service found on $address - wrong or unsupported cube model")
+            val keyIv = if (gen == GanGeneration.GEN2 && conn.name?.startsWith("AiCube") == true) GanDefinitions.MOYU_AI_KEY else GanDefinitions.GAN_KEY
+            val encrypter = GanEncrypter(aes, keyIv, mac)
+            val driver = when (gen) {
+                GanGeneration.GEN2 -> GanGen2ProtocolDriver(clock)
+                GanGeneration.GEN3 -> GanGen3ProtocolDriver(clock)
+                GanGeneration.GEN4 -> GanGen4ProtocolDriver(clock)
+            }
+            val notifications = conn.subscribe(gen.service, gen.state)
+            return GanSmartCube(scope, conn, gen, encrypter, driver, notifications)
+        } catch (e: Throwable) {
+            withContext(NonCancellable) { runCatching { conn.disconnect() } }
+            throw e
+        }
+    }
+
+    companion object {
+        /**
+         * Whether an advertisement looks like a GAN-protocol cube: a known name prefix, a GAN service UUID,
+         * or GAN-style manufacturer data whose embedded MAC matches the advertiser's address.
+         */
+        fun isGanCube(adv: BleAdvertisement): Boolean =
+            GanDefinitions.NAME_PREFIXES.any { adv.name?.startsWith(it) == true } ||
+                GanGeneration.fromServiceUuids(adv.serviceUuids) != null ||
+                GanDefinitions.macFromManufacturerData(adv.manufacturerData)?.equals(adv.address, ignoreCase = true) == true
+    }
+}
+
+/** A connected GAN cube: decrypts notifications, runs them through the generation's driver and publishes events. */
+class GanSmartCube internal constructor(
+    parent: CoroutineScope,
+    private val conn: BleConnection,
+    val generation: GanGeneration,
+    private val encrypter: GanEncrypter,
+    private val driver: GanProtocolDriver,
+    notifications: Flow<ByteArray>,
+) : SmartCube, GanRawConnection {
+    override val name: String? get() = conn.name
+    override val address: String get() = conn.address
+
+    private val scope = CoroutineScope(parent.coroutineContext + SupervisorJob(parent.coroutineContext[Job]))
+    private val _events = MutableSharedFlow<SmartCubeEvent>(extraBufferCapacity = 1024, onBufferOverflow = BufferOverflow.DROP_OLDEST)
+    override val events: SharedFlow<SmartCubeEvent> = _events.asSharedFlow()
+    private val writeLock = Mutex()
+    private var closed = false
+
+    init {
+        scope.launch(start = CoroutineStart.UNDISPATCHED) {
+            notifications.collect { raw ->
+                if (raw.size >= 16) {
+                    val plain = encrypter.decrypt(raw)
+                    driver.handleStateEvent(this@GanSmartCube, plain).forEach { _events.emit(it) }
+                }
+            }
+        }
+        scope.launch(start = CoroutineStart.UNDISPATCHED) {
+            conn.disconnected.first()
+            finish()
+        }
+    }
+
+    private fun finish() {
+        if (closed) return
+        closed = true
+        _events.tryEmit(SmartCubeEvent.Disconnected)
+        scope.cancel()
+    }
+
+    override suspend fun sendCommandMessage(message: ByteArray) {
+        writeLock.withLock { conn.write(generation.service, generation.command, encrypter.encrypt(message)) }
+    }
+
+    private suspend fun send(command: GanCommand) {
+        driver.createCommandMessage(command)?.let { sendCommandMessage(it) }
+    }
+
+    override suspend fun requestFacelets() = send(GanCommand.REQUEST_FACELETS)
+    override suspend fun requestBattery() = send(GanCommand.REQUEST_BATTERY)
+    override suspend fun requestHardware() = send(GanCommand.REQUEST_HARDWARE)
+    override suspend fun resetToSolved() = send(GanCommand.REQUEST_RESET)
+
+    override suspend fun disconnect() {
+        withContext(NonCancellable) {
+            runCatching { conn.disconnect() }
+            finish()
+        }
+    }
+}
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/bt/GanProtocol.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/bt/GanProtocol.kt
new file mode 100644
index 0000000..1aef3cd
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/bt/GanProtocol.kt
@@ -0,0 +1,307 @@
+// Protocol details ported from gan-web-bluetooth by Andy Fedotov, MIT License
+// (https://github.com/afedotov/gan-web-bluetooth).
+package coffee.liz.rookery.bt
+
+import coffee.liz.rookery.bt.SmartCubeEvent.Move
+
+enum class GanCommand { REQUEST_HARDWARE, REQUEST_FACELETS, REQUEST_BATTERY, REQUEST_RESET }
+
+/** What a protocol driver may do back to the cube while handling an event (move-history requests, disconnect). */
+interface GanRawConnection {
+    /** Encrypts and writes a plaintext command message. */
+    suspend fun sendCommandMessage(message: ByteArray)
+    suspend fun disconnect()
+}
+
+/** Encodes commands and decodes decrypted state notifications for one GAN protocol generation. */
+interface GanProtocolDriver {
+    fun createCommandMessage(command: GanCommand): ByteArray?
+    suspend fun handleStateEvent(conn: GanRawConnection, message: ByteArray): List<SmartCubeEvent>
+}
+
+private const val FACES = "URFDLB"
+private fun moveName(face: Int, direction: Int) = FACES[face].toString() + (if (direction == 1) "'" else "")
+
+private fun msgOf(size: Int, vararg head: Int) = ByteArray(size).also { b -> head.forEachIndexed { i, v -> b[i] = v.toByte() } }
+
+private fun signed15(q: Int): Double = (1 - (q shr 15) * 2) * (q and 0x7FFF) / 0x7FFF.toDouble()
+private fun signed3(v: Int): Int = (1 - (v shr 3) * 2) * (v and 0x7)
+
+private fun readState(r: GanBitReader, cpAt: Int, coAt: Int, epAt: Int, eoAt: Int): CubeState = GanFacelets.complete(
+    cp7 = List(7) { r.bits(cpAt + it * 3, 3) },
+    co7 = List(7) { r.bits(coAt + it * 2, 2) },
+    ep11 = List(11) { r.bits(epAt + it * 4, 4) },
+    eo11 = List(11) { r.bits(eoAt + it, 1) },
+)
+
+private fun facelets(state: CubeState, serial: Int) = SmartCubeEvent.Facelets(GanFacelets.toKociemba(state), serial, state)
+
+private fun gyro(r: GanBitReader, at: Int) = SmartCubeEvent.Gyro(
+    Quaternion(
+        x = signed15(r.bits(at + 16, 16)),
+        y = signed15(r.bits(at + 32, 16)),
+        z = signed15(r.bits(at + 48, 16)),
+        w = signed15(r.bits(at, 16)),
+    ),
+    AngularVelocity(signed3(r.bits(at + 64, 4)), signed3(r.bits(at + 68, 4)), signed3(r.bits(at + 72, 4))),
+)
+
+/**
+ * GAN Gen2: GAN Mini ui FreePlay, GAN12 ui (FreePlay), GAN356 i Carry (S), GAN356 i 3, Monster Go 3Ai, MoYu AI 2023.
+ * 20-byte messages; event type in the first nibble.
+ */
+class GanGen2ProtocolDriver(private val clock: () -> Long) : GanProtocolDriver {
+    private var lastSerial = -1
+    private var lastMoveTimestamp = 0L
+    private var cubeTimestamp = 0L
+
+    override fun createCommandMessage(command: GanCommand): ByteArray = when (command) {
+        GanCommand.REQUEST_FACELETS -> msgOf(20, 0x04)
+        GanCommand.REQUEST_HARDWARE -> msgOf(20, 0x05)
+        GanCommand.REQUEST_BATTERY -> msgOf(20, 0x09)
+        GanCommand.REQUEST_RESET -> msgOf(20, 0x0A, 0x05, 0x39, 0x77, 0x00, 0x00, 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB)
+    }
+
+    override suspend fun handleStateEvent(conn: GanRawConnection, message: ByteArray): List<SmartCubeEvent> {
+        val timestamp = clock()
+        val events = mutableListOf<SmartCubeEvent>()
+        val r = GanBitReader(message)
+        when (r.bits(0, 4)) {
+            0x01 -> events += gyro(r, 4)
+            0x02 -> if (lastSerial != -1) { // moves are accepted only after the first facelets event
+                val serial = r.bits(4, 8)
+                val diff = minOf((serial - lastSerial) and 0xFF, 7)
+                lastSerial = serial
+                if (diff > 0) {
+                    for (i in diff - 1 downTo 0) {
+                        val face = r.bits(12 + 5 * i, 4)
+                        val direction = r.bits(16 + 5 * i, 1)
+                        var elapsed = r.bits(47 + 16 * i, 16).toLong()
+                        if (elapsed == 0L) elapsed = timestamp - lastMoveTimestamp // 16-bit cube timer overflow
+                        cubeTimestamp += elapsed
+                        if (face < FACES.length) {
+                            events += Move(moveName(face, direction), cubeTimestamp, timestamp, (serial - i) and 0xFF, recovered = i != 0)
+                        }
+                    }
+                    lastMoveTimestamp = timestamp
+                }
+            }
+            0x04 -> {
+                val serial = r.bits(4, 8)
+                if (lastSerial == -1) lastSerial = serial
+                events += facelets(readState(r, 12, 33, 47, 91), serial)
+            }
+            0x05 -> {
+                val hwMajor = r.bits(8, 8); val hwMinor = r.bits(16, 8)
+                val swMajor = r.bits(24, 8); val swMinor = r.bits(32, 8)
+                val gyroSupported = r.bits(104, 1) == 1
+                val name = (0 until 8).map { r.bits(it * 8 + 40, 8).toChar() }.joinToString("")
+                events += SmartCubeEvent.Hardware(name.trimEnd('\u0000'), "$hwMajor.$hwMinor", "$swMajor.$swMinor", null, gyroSupported)
+            }
+            0x09 -> events += SmartCubeEvent.Battery(minOf(r.bits(8, 8), 100))
+            0x0D -> conn.disconnect()
+        }
+        return events
+    }
+}
+
+/**
+ * Shared move FIFO with gap detection and move-history recovery used by Gen3 and Gen4:
+ * live moves carry a serial; when one is skipped, the driver asks the cube for its move history
+ * and holds later moves back until the gap is filled.
+ */
+abstract class GanBufferedProtocolDriver(protected val clock: () -> Long) : GanProtocolDriver {
+    protected var serial = -1
+    protected var lastSerial = -1
+    protected var lastLocalTimestamp: Long? = null
+    private val moveBuffer = ArrayDeque<Move>()
+
+    protected abstract fun moveHistoryMessage(serial: Int, count: Int): ByteArray
+
+    private suspend fun requestMoveHistory(conn: GanRawConnection, serialIn: Int, countIn: Int) {
+        // History data is byte-aligned and always starts at an odd serial: request an odd-aligned, even-sized window,
+        // and never across the 255 -> 0 edge (firmware spoofs those as 'D').
+        var s = serialIn
+        var count = countIn
+        if (s % 2 == 0) s = (s - 1) and 0xFF
+        if (count % 2 == 1) count++
+        count = minOf(count, s + 1)
+        try {
+            conn.sendCommandMessage(moveHistoryMessage(s, count))
+        } catch (e: Exception) {
+            if (e is kotlinx.coroutines.CancellationException) throw e
+            // Ignored: retried on the next move event.
+        }
+    }
+
+    protected suspend fun evictMoveBuffer(conn: GanRawConnection?): List<SmartCubeEvent> {
+        val evicted = mutableListOf<SmartCubeEvent>()
+        while (moveBuffer.isNotEmpty()) {
+            val head = moveBuffer.first()
+            val diff = if (lastSerial == -1) 1 else (head.serial - lastSerial) and 0xFF
+            if (diff > 1) {
+                if (conn != null) requestMoveHistory(conn, head.serial, diff)
+                break
+            } else {
+                evicted += moveBuffer.removeFirst()
+                lastSerial = head.serial
+            }
+        }
+        // Something went wrong and the buffer no longer drains: drop the connection.
+        if (conn != null && moveBuffer.size > 16) conn.disconnect()
+        return evicted
+    }
+
+    private fun isSerialInRange(start: Int, end: Int, serial: Int, closedStart: Boolean = false, closedEnd: Boolean = false) =
+        ((end - start) and 0xFF) >= ((serial - start) and 0xFF) &&
+            (closedStart || ((start - serial) and 0xFF) > 0) &&
+            (closedEnd || ((end - serial) and 0xFF) > 0)
+
+    private fun injectMissedMove(move: Move) {
+        if (moveBuffer.isNotEmpty()) {
+            val head = moveBuffer.first()
+            if (moveBuffer.any { it.serial == move.serial }) return
+            if (!isSerialInRange(lastSerial, head.serial, move.serial)) return
+            // History is injected in reverse order, so only the move right before the head fits.
+            if (move.serial == ((head.serial - 1) and 0xFF)) moveBuffer.addFirst(move)
+        } else if (isSerialInRange(lastSerial, serial, move.serial, closedEnd = true)) {
+            // A lost move recovered via the periodic facelets event, into an empty buffer.
+            moveBuffer.addFirst(move)
+        }
+    }
+
+    private suspend fun checkIfMoveMissed(conn: GanRawConnection) {
+        val diff = (serial - lastSerial) and 0xFF
+        if (diff > 0 && serial != 0) { // serial 0: firmware bug with facelets event at counter 255
+            val startSerial = moveBuffer.firstOrNull()?.serial ?: ((serial + 1) and 0xFF)
+            requestMoveHistory(conn, startSerial, diff + 1)
+        }
+    }
+
+    protected suspend fun onLiveMove(conn: GanRawConnection, timestamp: Long, cubeTimestamp: Long, moveSerial: Int, direction: Int, faceBits: Int): List<SmartCubeEvent> {
+        if (lastSerial == -1) return emptyList() // moves are accepted only after the first facelets event
+        lastLocalTimestamp = timestamp
+        serial = moveSerial
+        val face = LIVE_FACE_BITS.indexOf(faceBits)
+        if (face >= 0) moveBuffer.addLast(Move(moveName(face, direction), cubeTimestamp, timestamp, moveSerial))
+        return evictMoveBuffer(conn)
+    }
+
+    protected suspend fun onMoveHistory(r: GanBitReader, timestamp: Long, startSerial: Int, dataLength: Int, movesAt: Int): List<SmartCubeEvent> {
+        val count = (dataLength - 1) * 2
+        for (i in 0 until count) {
+            val face = HISTORY_FACE_BITS.indexOf(r.bits(movesAt + 4 * i, 3))
+            val direction = r.bits(movesAt + 3 + 4 * i, 1)
+            if (face >= 0) injectMissedMove(Move(moveName(face, direction), null, timestamp, (startSerial - i) and 0xFF, recovered = true))
+        }
+        return evictMoveBuffer(null)
+    }
+
+    protected suspend fun onFaceletsSerial(conn: GanRawConnection, timestamp: Long, faceletsSerial: Int) {
+        serial = faceletsSerial
+        // The cube sends facelets periodically; use them to detect missed moves, debounced while turning.
+        if (lastSerial != -1) {
+            val last = lastLocalTimestamp
+            if (last != null && timestamp - last > 500) checkIfMoveMissed(conn)
+        }
+        if (lastSerial == -1) lastSerial = faceletsSerial
+    }
+
+    private companion object {
+        val LIVE_FACE_BITS = listOf(2, 32, 8, 1, 16, 4)
+        val HISTORY_FACE_BITS = listOf(1, 5, 3, 0, 4, 2)
+    }
+}
+
+/** GAN Gen3: GAN356 i Carry 2. 16-byte messages starting with magic 0x55, type, length. */
+class GanGen3ProtocolDriver(clock: () -> Long) : GanBufferedProtocolDriver(clock) {
+    override fun createCommandMessage(command: GanCommand): ByteArray = when (command) {
+        GanCommand.REQUEST_FACELETS -> msgOf(16, 0x68, 0x01)
+        GanCommand.REQUEST_HARDWARE -> msgOf(16, 0x68, 0x04)
+        GanCommand.REQUEST_BATTERY -> msgOf(16, 0x68, 0x07)
+        GanCommand.REQUEST_RESET -> msgOf(16, 0x68, 0x05, 0x05, 0x39, 0x77, 0x00, 0x00, 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB)
+    }
+
+    override fun moveHistoryMessage(serial: Int, count: Int) = msgOf(16, 0x68, 0x03, serial, 0, count, 0)
+
+    override suspend fun handleStateEvent(conn: GanRawConnection, message: ByteArray): List<SmartCubeEvent> {
+        val timestamp = clock()
+        val r = GanBitReader(message)
+        val magic = r.bits(0, 8)
+        val eventType = r.bits(8, 8)
+        val dataLength = r.bits(16, 8)
+        if (magic != 0x55 || dataLength <= 0) return emptyList()
+        return when (eventType) {
+            0x01 -> onLiveMove(conn, timestamp, r.u32(24, true), r.bits(56, 16, true) and 0xFF, r.bits(72, 2), r.bits(74, 6))
+            0x06 -> onMoveHistory(r, timestamp, r.bits(24, 8), dataLength, 32)
+            0x02 -> {
+                val s = r.bits(24, 16, true) and 0xFF
+                onFaceletsSerial(conn, timestamp, s)
+                listOf(facelets(readState(r, 40, 61, 77, 121), s))
+            }
+            0x07 -> {
+                val swMajor = r.bits(72, 4); val swMinor = r.bits(76, 4)
+                val hwMajor = r.bits(80, 4); val hwMinor = r.bits(84, 4)
+                val name = (0 until 5).map { r.bits(it * 8 + 32, 8).toChar() }.joinToString("")
+                listOf(SmartCubeEvent.Hardware(name.trimEnd('\u0000'), "$hwMajor.$hwMinor", "$swMajor.$swMinor", null, false))
+            }
+            0x10 -> listOf(SmartCubeEvent.Battery(minOf(r.bits(24, 8), 100)))
+            0x11 -> { conn.disconnect(); emptyList() }
+            else -> emptyList()
+        }
+    }
+}
+
+/** GAN Gen4: GAN12 ui Maglev, GAN14 ui FreePlay. 20-byte messages starting with type, length. */
+class GanGen4ProtocolDriver(clock: () -> Long) : GanBufferedProtocolDriver(clock) {
+    private val hwInfo = mutableMapOf<Int, String>()
+
+    override fun createCommandMessage(command: GanCommand): ByteArray = when (command) {
+        GanCommand.REQUEST_FACELETS -> msgOf(20, 0xDD, 0x04, 0x00, 0xED, 0x00, 0x00)
+        GanCommand.REQUEST_HARDWARE -> { hwInfo.clear(); msgOf(20, 0xDF, 0x03, 0x00, 0x00, 0x00) }
+        GanCommand.REQUEST_BATTERY -> msgOf(20, 0xDD, 0x04, 0x00, 0xEF, 0x00, 0x00)
+        GanCommand.REQUEST_RESET -> msgOf(20, 0xD2, 0x0D, 0x05, 0x39, 0x77, 0x00, 0x00, 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB)
+    }
+
+    override fun moveHistoryMessage(serial: Int, count: Int) = msgOf(20, 0xD1, 0x04, serial, 0, count, 0)
+
+    override suspend fun handleStateEvent(conn: GanRawConnection, message: ByteArray): List<SmartCubeEvent> {
+        val timestamp = clock()
+        val r = GanBitReader(message)
+        val eventType = r.bits(0, 8)
+        val dataLength = r.bits(8, 8)
+        return when (eventType) {
+            0x01 -> onLiveMove(conn, timestamp, r.u32(16, true), r.bits(48, 16, true) and 0xFF, r.bits(64, 2), r.bits(66, 6))
+            0xD1 -> onMoveHistory(r, timestamp, r.bits(16, 8), dataLength, 24)
+            0xED -> {
+                val s = r.bits(16, 16, true) and 0xFF
+                onFaceletsSerial(conn, timestamp, s)
+                listOf(facelets(readState(r, 32, 53, 69, 113), s))
+            }
+            in 0xFA..0xFE -> {
+                when (eventType) {
+                    0xFA -> {
+                        val year = r.bits(24, 16, true); val month = r.bits(40, 8); val day = r.bits(48, 8)
+                        hwInfo[eventType] = "${year.toString().padStart(4, '0')}-${month.toString().padStart(2, '0')}-${day.toString().padStart(2, '0')}"
+                    }
+                    0xFC -> hwInfo[eventType] = (0 until maxOf(0, minOf(dataLength - 1, (message.size * 8 - 24) / 8)))
+                        .map { r.bits(it * 8 + 24, 8).toChar() }.joinToString("")
+                    0xFD -> hwInfo[eventType] = "${r.bits(24, 4)}.${r.bits(28, 4)}"
+                    0xFE -> hwInfo[eventType] = "${r.bits(24, 4)}.${r.bits(28, 4)}"
+                }
+                if (hwInfo.size == 4) {
+                    val name = hwInfo[0xFC]
+                    listOf(SmartCubeEvent.Hardware(name, hwInfo[0xFE], hwInfo[0xFD], hwInfo[0xFA], name in GYRO_MODELS))
+                } else emptyList()
+            }
+            0xEC -> listOf(gyro(r, 16))
+            0xEF -> listOf(SmartCubeEvent.Battery(minOf(r.bits(8 + dataLength * 8, 8), 100)))
+            0xEA -> { conn.disconnect(); emptyList() }
+            else -> emptyList()
+        }
+    }
+
+    private companion object {
+        val GYRO_MODELS = setOf("GAN12uiM")
+    }
+}
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/bt/GanUtil.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/bt/GanUtil.kt
new file mode 100644
index 0000000..c5521f0
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/bt/GanUtil.kt
@@ -0,0 +1,138 @@
+// Protocol details ported from gan-web-bluetooth by Andy Fedotov, MIT License
+// (https://github.com/afedotov/gan-web-bluetooth).
+package coffee.liz.rookery.bt
+
+import kotlin.math.roundToLong
+
+/**
+ * Reads arbitrary bit words from a message, MSB-first; 16/32-bit words may be little-endian.
+ * Bits past the end read as 0.
+ */
+class GanBitReader(private val msg: ByteArray) {
+    private fun bit(i: Int): Int = if (i ushr 3 >= msg.size) 0 else (msg[i ushr 3].toInt() ushr (7 - (i and 7))) and 1
+
+    fun bits(start: Int, length: Int, littleEndian: Boolean = false): Int = when {
+        length <= 8 -> {
+            var v = 0
+            for (i in start until start + length) v = (v shl 1) or bit(i)
+            v
+        }
+        length == 16 || length == 32 -> {
+            val n = length / 8
+            val bytes = IntArray(n) { bits(start + 8 * it, 8) }
+            var v = 0L
+            for (i in 0 until n) v = (v shl 8) or (if (littleEndian) bytes[n - 1 - i] else bytes[i]).toLong()
+            v.toInt()
+        }
+        else -> throw IllegalArgumentException("Unsupported bit word length $length")
+    }
+
+    /** Unsigned 32-bit word as Long. */
+    fun u32(start: Int, littleEndian: Boolean = false): Long = bits(start, 32, littleEndian).toLong() and 0xFFFFFFFFL
+}
+
+/** Writes bit words MSB-first; the inverse of [GanBitReader] (used by tests and encoders). */
+class GanBitWriter(size: Int) {
+    val bytes = ByteArray(size)
+
+    fun put(start: Int, length: Int, value: Long, littleEndian: Boolean = false): GanBitWriter {
+        if (length == 16 || length == 32) {
+            val n = length / 8
+            for (i in 0 until n) {
+                val shift = if (littleEndian) 8 * i else 8 * (n - 1 - i)
+                put(start + 8 * i, 8, (value ushr shift) and 0xFF)
+            }
+            return this
+        }
+        require(length <= 8)
+        for (i in 0 until length) {
+            val b = ((value ushr (length - 1 - i)) and 1L).toInt()
+            val pos = start + i
+            val idx = pos ushr 3
+            val mask = 1 shl (7 - (pos and 7))
+            bytes[idx] = (if (b == 1) bytes[idx].toInt() or mask else bytes[idx].toInt() and mask.inv()).toByte()
+        }
+        return this
+    }
+
+    fun put(start: Int, length: Int, value: Int, littleEndian: Boolean = false) = put(start, length, value.toLong() and 0xFFFFFFFFL, littleEndian)
+}
+
+object GanFacelets {
+    private val CORNER_FACELET_MAP = arrayOf(
+        intArrayOf(8, 9, 20), intArrayOf(6, 18, 38), intArrayOf(0, 36, 47), intArrayOf(2, 45, 11),
+        intArrayOf(29, 26, 15), intArrayOf(27, 44, 24), intArrayOf(33, 53, 42), intArrayOf(35, 17, 51),
+    )
+    private val EDGE_FACELET_MAP = arrayOf(
+        intArrayOf(5, 10), intArrayOf(7, 19), intArrayOf(3, 37), intArrayOf(1, 46),
+        intArrayOf(32, 16), intArrayOf(28, 25), intArrayOf(30, 43), intArrayOf(34, 52),
+        intArrayOf(23, 12), intArrayOf(21, 41), intArrayOf(50, 39), intArrayOf(48, 14),
+    )
+    private const val FACES = "URFDLB"
+
+    const val SOLVED = "UUUUUUUUURRRRRRRRRFFFFFFFFFDDDDDDDDDLLLLLLLLLBBBBBBBBB"
+
+    /** Corner/edge permutation+orientation to a Kociemba facelets string. */
+    fun toKociemba(s: CubeState): String {
+        val f = CharArray(54) { FACES[it / 9] }
+        for (i in 0 until 8) for (p in 0 until 3)
+            f[CORNER_FACELET_MAP[i][(p + s.co[i]) % 3]] = FACES[CORNER_FACELET_MAP[s.cp[i]][p] / 9]
+        for (i in 0 until 12) for (p in 0 until 2)
+            f[EDGE_FACELET_MAP[i][(p + s.eo[i]) % 2]] = FACES[EDGE_FACELET_MAP[s.ep[i]][p] / 9]
+        return f.concatToString()
+    }
+
+    /** Fill in the 8th corner / 12th edge from the first 7/11 (the cube only sends those). */
+    fun complete(cp7: List<Int>, co7: List<Int>, ep11: List<Int>, eo11: List<Int>): CubeState = CubeState(
+        cp = cp7 + (28 - cp7.sum()),
+        co = co7 + ((3 - co7.sum() % 3) % 3),
+        ep = ep11 + (66 - ep11.sum()),
+        eo = eo11 + ((2 - eo11.sum() % 2) % 2),
+    )
+}
+
+/** A move with optional timestamps, for [GanTimestampFit]. */
+data class TimedMove(val move: String, val hostTimestampMs: Long?, val cubeTimestampMs: Long?)
+
+object GanTimestampFit {
+    private fun linregress(x: List<Long?>, y: List<Long?>): Pair<Double, Double> {
+        var sumX = 0.0; var sumY = 0.0; var sumXY = 0.0; var sumXX = 0.0; var n = 0
+        for (i in x.indices) {
+            val xi = x[i]?.toDouble() ?: continue
+            val yi = y[i]?.toDouble() ?: continue
+            n++; sumX += xi; sumY += yi; sumXY += xi * yi; sumXX += xi * xi
+        }
+        val varX = n * sumXX - sumX * sumX
+        val covXY = n * sumXY - sumX * sumY
+        val slope = if (varX < 1e-3) 1.0 else covXY / varX
+        val intercept = if (n < 1) 0.0 else sumY / n - slope * sumX / n
+        return slope to intercept
+    }
+
+    /**
+     * Fit cube-clock timestamps to host timestamps by linear regression, first filling missing cube
+     * timestamps from neighbours (next -50 ms, then previous +50 ms). Returned cube timestamps are in
+     * host-clock milliseconds relative to the first move (so the first is 0).
+     */
+    fun linearFit(moves: List<TimedMove>): List<TimedMove> {
+        if (moves.isEmpty()) return emptyList()
+        val cube = moves.map { it.cubeTimestampMs }.toMutableList()
+        if (cube.size >= 2) {
+            for (i in cube.size - 1 downTo 1) if (cube[i] != null && cube[i - 1] == null) cube[i - 1] = cube[i]!! - 50
+            for (i in 0 until cube.size - 1) if (cube[i] != null && cube[i + 1] == null) cube[i + 1] = cube[i]!! + 50
+        }
+        val (slope, intercept) = linregress(cube, moves.map { it.hostTimestampMs })
+        val first = cube[0]?.let { (slope * it + intercept).roundToLong() }
+        return moves.mapIndexed { i, m ->
+            val c = cube[i]
+            m.copy(cubeTimestampMs = if (c == null || first == null) null else (slope * c + intercept).roundToLong() - first)
+        }
+    }
+
+    /** Skew of the cube clock vs the host clock, in percent. */
+    fun skewPercent(moves: List<TimedMove>): Double {
+        if (moves.isEmpty()) return 0.0
+        val (slope, _) = linregress(moves.map { it.hostTimestampMs }, moves.map { it.cubeTimestampMs })
+        return ((slope - 1) * 100000).roundToLong() / 1000.0
+    }
+}
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/bt/SmartCube.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/bt/SmartCube.kt
new file mode 100644
index 0000000..747a391
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/bt/SmartCube.kt
@@ -0,0 +1,58 @@
+package coffee.liz.rookery.bt
+
+import kotlinx.coroutines.flow.Flow
+
+/** Orientation quaternion; right-handed, +X red, +Y blue, +Z white (GAN convention). */
+data class Quaternion(val x: Double, val y: Double, val z: Double, val w: Double)
+
+/** Coarse angular velocity per axis as reported by the cube (small signed integers). */
+data class AngularVelocity(val x: Int, val y: Int, val z: Int)
+
+/** Corner/edge permutation and orientation as reported by the cube. */
+data class CubeState(val cp: List<Int>, val co: List<Int>, val ep: List<Int>, val eo: List<Int>)
+
+sealed interface SmartCubeEvent {
+    /**
+     * A face turn in WCA notation ("R", "U'").
+     * [cubeTimestampMs] is the cube's own clock (null if unknown, e.g. a move recovered from history);
+     * [hostTimestampMs] is the host's monotonic clock when the notification arrived.
+     * [recovered] marks moves that were missed live and filled in from the cube's move history,
+     * whose host timestamp is therefore not meaningful.
+     */
+    data class Move(
+        val move: String,
+        val cubeTimestampMs: Long?,
+        val hostTimestampMs: Long,
+        val serial: Int = -1,
+        val recovered: Boolean = false,
+    ) : SmartCubeEvent
+
+    /** Kociemba-style 54-char facelets in U R F D L B order. */
+    data class Facelets(val facelets: String, val serial: Int = -1, val state: CubeState? = null) : SmartCubeEvent
+
+    data class Battery(val percent: Int) : SmartCubeEvent
+
+    data class Hardware(
+        val name: String?,
+        val hardwareVersion: String?,
+        val softwareVersion: String?,
+        val productDate: String? = null,
+        val gyroSupported: Boolean = false,
+    ) : SmartCubeEvent
+
+    data class Gyro(val quaternion: Quaternion, val velocity: AngularVelocity? = null) : SmartCubeEvent
+
+    data object Disconnected : SmartCubeEvent
+}
+
+/** A connected smart cube. [events] is hot: collect it before issuing requests to see their replies. */
+interface SmartCube {
+    val name: String?
+    val address: String
+    val events: Flow<SmartCubeEvent>
+    suspend fun requestFacelets()
+    suspend fun requestBattery()
+    suspend fun requestHardware()
+    suspend fun resetToSolved()
+    suspend fun disconnect()
+}
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/importer/CsTimerImport.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/importer/CsTimerImport.kt
new file mode 100644
index 0000000..5d398bd
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/importer/CsTimerImport.kt
@@ -0,0 +1,104 @@
+package coffee.liz.rookery.importer
+
+import coffee.liz.rookery.model.CubeDevice
+import coffee.liz.rookery.model.Event
+import coffee.liz.rookery.model.Penalty
+import coffee.liz.rookery.model.Session
+import coffee.liz.rookery.model.Solve
+import coffee.liz.rookery.util.fnv64
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.contentOrNull
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import kotlinx.serialization.json.longOrNull
+
+/**
+ * Parses a csTimer export (the `.txt` from Export → to file).
+ *
+ * Shape: `{"session1": [solve...], ..., "properties": {"sessionData": "<json string>", "giiMacMap": "<json string>"}}`
+ * where a solve is `[[penalty, ms], scramble, comment, unixSeconds, [moves, puzzle]?]` and penalty is
+ * 0, 2000 (+2) or -1 (DNF).
+ *
+ * csTimer lets one session hold several puzzles, so each (session, event) pair becomes its own session
+ * here. Ids are hashes of the source data, so importing the same file twice changes nothing.
+ */
+object CsTimerImport {
+    data class Result(val sessions: List<Session>, val solves: List<Solve>, val devices: List<CubeDevice>, val warnings: List<String>)
+
+    private val json = Json { ignoreUnknownKeys = true; isLenient = true }
+
+    fun parse(text: String): Result {
+        val root = json.parseToJsonElement(text).jsonObject
+        val props = root["properties"] as? JsonObject
+        val sessionData = props?.get("sessionData")?.let(::embedded)
+        val warnings = mutableListOf<String>()
+
+        val sessions = LinkedHashMap<String, Session>()
+        val solves = mutableListOf<Solve>()
+
+        val keys = root.keys.filter { it.startsWith("session") }.sortedBy { it.removePrefix("session").toIntOrNull() ?: 0 }
+        for (key in keys) {
+            val num = key.removePrefix("session")
+            val meta = sessionData?.get(num) as? JsonObject
+            val name = (meta?.get("name") as? JsonPrimitive)?.contentOrNull ?: num
+            val scrType = ((meta?.get("opt") as? JsonObject)?.get("scrType") as? JsonPrimitive)?.contentOrNull
+            val sessionEvent = EventGuess.fromCsTimerType(scrType)
+            if (scrType != null && sessionEvent == null) warnings += "session $name: unknown scramble type '$scrType', guessing per solve"
+
+            for ((i, el) in (root[key] as? JsonArray ?: continue).withIndex()) {
+                val arr = el as? JsonArray ?: continue
+                try {
+                    val timeArr = arr[0].jsonArray
+                    val pen = timeArr[0].jsonPrimitive.longOrNull ?: 0
+                    val ms = timeArr[1].jsonPrimitive.longOrNull ?: continue
+                    val scramble = arr.getOrNull(1)?.jsonPrimitive?.contentOrNull.orEmpty()
+                    val comment = arr.getOrNull(2)?.jsonPrimitive?.contentOrNull.orEmpty()
+                    val at = (arr.getOrNull(3)?.jsonPrimitive?.longOrNull ?: 0) * 1000
+                    val moves = (arr.getOrNull(4) as? JsonArray)?.getOrNull(0)?.jsonPrimitive?.contentOrNull
+
+                    // The scramble wins when it clearly names a different puzzle than the session's type.
+                    val sniffed = EventGuess.fromScramble(scramble)
+                    val event = when {
+                        sniffed != null && sniffed.puzzle != sessionEvent?.puzzle && (sessionEvent == null || EventGuess.isUnambiguous(sniffed)) -> sniffed
+                        sessionEvent != null -> sessionEvent
+                        else -> sniffed ?: Event.E333
+                    }
+                    val sid = "cst-" + fnv64(num, event.id)
+                    sessions.getOrPut(sid) {
+                        val suffix = if (sessionEvent == null || event != sessionEvent) " (${event.short})" else ""
+                        Session(sid, "csTimer $name$suffix", event, at)
+                    }.let { if (at < it.createdAt) sessions[sid] = it.copy(createdAt = at) }
+
+                    solves += Solve(
+                        id = "cst-" + fnv64(at.toString(), ms.toString(), scramble),
+                        sessionId = sid, event = event, ms = ms,
+                        penalty = when { pen < 0 -> Penalty.DNF; pen > 0 -> Penalty.PLUS2; else -> Penalty.NONE },
+                        scramble = scramble, comment = comment, at = at, moves = moves,
+                    )
+                } catch (e: Exception) {
+                    warnings += "$key #${i + 1}: skipped (${e.message})"
+                }
+            }
+        }
+
+        val devices = props?.get("giiMacMap")?.let(::embedded)?.values
+            ?.mapNotNull { (it as? JsonPrimitive)?.contentOrNull }
+            ?.filter { it.matches(Regex("([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}")) }
+            ?.distinct()
+            ?.map { CubeDevice(it.uppercase(), "Smart cube (from csTimer)", "gan") }
+            .orEmpty()
+
+        return Result(sessions.values.toList(), solves, devices, warnings)
+    }
+
+    /** csTimer stores some properties as JSON-encoded strings inside the JSON. */
+    private fun embedded(e: kotlinx.serialization.json.JsonElement): JsonObject? = when (e) {
+        is JsonObject -> e
+        is JsonPrimitive -> e.contentOrNull?.let { runCatching { json.parseToJsonElement(it).jsonObject }.getOrNull() }
+        else -> null
+    }
+}
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/importer/EventGuess.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/importer/EventGuess.kt
new file mode 100644
index 0000000..c8c5624
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/importer/EventGuess.kt
@@ -0,0 +1,58 @@
+package coffee.liz.rookery.importer
+
+import coffee.liz.rookery.model.Event
+
+/** Best-effort mapping from csTimer scramble types and raw scrambles to events. */
+object EventGuess {
+    /** csTimer `scrType` values → events. Unknown types fall back to scramble sniffing. */
+    fun fromCsTimerType(t: String?): Event? = when (t) {
+        null, "" -> null
+        "333", "333o", "333oh", "333ft" -> if (t == "333oh") Event.E333OH else Event.E333
+        "222so", "222o", "2223", "222eg" -> Event.E222
+        "444wca", "444m", "444o", "444" -> Event.E444
+        "555wca", "555", "555bld" -> if (t == "555bld") Event.E555BF else Event.E555
+        "666wca", "666si", "666" -> Event.E666
+        "777wca", "777si", "777" -> Event.E777
+        "333ni", "333bld" -> Event.E333BF
+        "444bld" -> Event.E444BF
+        "r3ni" -> Event.E333MBF
+        "333fm" -> Event.E333FM
+        "clkwca", "clk", "clko" -> Event.CLOCK
+        "mgmp", "mgmc", "mgmo" -> Event.MINX
+        "pyrso", "pyrm", "pyro" -> Event.PYRAM
+        "skbso", "skbo" -> Event.SKEWB
+        "sqrs", "sq1h", "sq1t" -> Event.SQ1
+        "ftoso", "fto" -> Event.FTO
+        else -> null
+    }
+
+    /**
+     * Whether a scramble-text guess is distinctive enough to override what the session says.
+     * Short 2x2 / Pyraminx / Skewb scrambles look alike, so those never override.
+     */
+    fun isUnambiguous(e: Event): Boolean = e.puzzle !in setOf(
+        coffee.liz.rookery.model.Puzzle.CUBE2, coffee.liz.rookery.model.Puzzle.PYRAMINX, coffee.liz.rookery.model.Puzzle.SKEWB,
+    )
+
+    /** Guess from the scramble text alone. Returns null when it looks like a plain 3x3 scramble. */
+    fun fromScramble(scr: String): Event? {
+        val s = scr.trim()
+        if (s.isEmpty()) return null
+        if (s.contains('/') && s.contains('(')) return Event.SQ1
+        if (Regex("""\b(UR|DR|DL|UL|ALL)\d[+-]""").containsMatchIn(s) || s.contains("y2 ")) return Event.CLOCK
+        if (s.contains("++") || s.contains("--")) return Event.MINX
+        val tokens = s.split(Regex("\\s+"))
+        if (tokens.any { it.matches(Regex("""(BR|BL)'?""")) }) return Event.FTO
+        if (tokens.all { it.matches(Regex("""[ULRBulrb]'?""")) }) {
+            return if (tokens.any { it[0].isLowerCase() }) Event.PYRAM else Event.SKEWB
+        }
+        val wide3 = tokens.any { it.matches(Regex("""3[URFDLB]w.*""")) }
+        val wide = tokens.any { it.contains('w') }
+        return when {
+            wide3 -> if (tokens.size >= 90) Event.E777 else Event.E666
+            wide -> if (tokens.size >= 55) Event.E555 else Event.E444
+            tokens.size in 8..12 && tokens.all { it.matches(Regex("""[URF][2']?""")) } -> Event.E222
+            else -> null
+        }
+    }
+}
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/importer/Importer.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/importer/Importer.kt
new file mode 100644
index 0000000..25b39a6
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/importer/Importer.kt
@@ -0,0 +1,81 @@
+package coffee.liz.rookery.importer
+
+import coffee.liz.rookery.store.Coll
+import coffee.liz.rookery.store.Repo
+import coffee.liz.rookery.util.fnv64
+import kotlinx.serialization.json.JsonPrimitive
+
+/** Writes parsed imports into the store. Every id is derived from source data, so re-running is a no-op. */
+class Importer(private val repo: Repo) {
+    data class Summary(val lines: List<String>, val warnings: List<String> = emptyList())
+
+    fun csTimer(text: String): Summary {
+        val r = CsTimerImport.parse(text)
+        val existingSessions = repo.sessions().map { it.id }.toSet()
+        val existingSolves = repo.solves().map { it.id }.toSet()
+        val existingDevices = repo.devices().map { it.mac }.toSet()
+        val newSessions = r.sessions.filter { it.id !in existingSessions }
+        val newSolves = r.solves.filter { it.id !in existingSolves }
+        val newDevices = r.devices.filter { it.mac !in existingDevices }
+        repo.store.transact {
+            for (s in newSessions) {
+                set(Coll.SESSION, s.id, "name", s.name); set(Coll.SESSION, s.id, "event", s.event.id); set(Coll.SESSION, s.id, "created", s.createdAt)
+            }
+            with(repo) { for (s in newSolves) writeSolve(s) }
+            for (d in newDevices) {
+                set(Coll.DEVICE, d.mac, "name", d.name); set(Coll.DEVICE, d.mac, "proto", d.protocol)
+            }
+        }
+        val byEvent = newSolves.groupingBy { it.event.short }.eachCount().entries.joinToString { "${it.value} ${it.key}" }
+        return Summary(
+            listOfNotNull(
+                "${newSolves.size} new solves" + (if (byEvent.isNotEmpty()) " ($byEvent)" else "") + ", ${r.solves.size - newSolves.size} already here",
+                "${newSessions.size} new sessions",
+                "${newSolves.count { it.moves != null }} with smart-cube reconstructions",
+                if (newDevices.isNotEmpty()) "remembered smart cube ${newDevices.joinToString { it.mac }}" else null,
+            ),
+            r.warnings,
+        )
+    }
+
+    /** [image] loads a file from the export by its relative path (null if missing). */
+    fun letterPairGym(text: String, image: (String) -> ByteArray?): Summary {
+        val r = LetterPairGymImport.parse(text)
+        val existing = repo.letterPairs()
+        val warnings = mutableListOf<String>()
+        var images = 0
+        val blobByPair = r.images.mapNotNull { (pair, path) ->
+            val bytes = image(path)
+            if (bytes == null) { warnings += "$pair: image $path missing from export"; null }
+            else pair to repo.store.blobs.put(bytes, path.substringAfterLast('.', "jpg").lowercase())
+        }.toMap()
+
+        repo.store.transact {
+            for ((pair, word) in r.words) {
+                val cur = existing[pair]
+                if (cur?.primary != word) set(Coll.PAIR, pair, "primary", word)
+                if (cur == null || word !in cur.words) set(Coll.PAIR, pair, "w:$word", true)
+            }
+            for ((pair, note) in r.notes) if (existing[pair]?.note != note) set(Coll.PAIR, pair, "note", note)
+            for ((pair, blob) in blobByPair) if (existing[pair]?.image != blob) { set(Coll.PAIR, pair, "image", blob); images++ }
+            for (h in r.history) {
+                set(Coll.PAIR_HISTORY, fnv64(h.pair, h.from.orEmpty(), h.to.orEmpty(), h.at.toString()), "v", Repo.historyJson(h))
+            }
+            for ((pair, s) in r.stats) set(Coll.PAIR, pair, "gymStats", s.raw)
+            for (m in r.memo) {
+                val id = "lpg-" + m.at
+                set(Coll.MEMO, id, "at", m.at); set(Coll.MEMO, id, "pairs", m.pairs); set(Coll.MEMO, id, "ms", m.memoMs); set(Coll.MEMO, id, "ok", m.recalled)
+            }
+            r.settings?.let { set(Coll.PREFS, "global", "importedLetterPairGymSettings", JsonPrimitive(it.toString())) }
+        }
+        return Summary(
+            listOf(
+                "${r.words.size} letter pairs (${r.words.keys.count { it !in existing }} new)",
+                "${r.notes.size} notes, $images images",
+                "${r.history.size} word changes, practice stats for ${r.stats.size} pairs",
+                "${r.memo.size} memo sessions",
+            ),
+            warnings,
+        )
+    }
+}
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/importer/LetterPairGymImport.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/importer/LetterPairGymImport.kt
new file mode 100644
index 0000000..b6a84a1
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/importer/LetterPairGymImport.kt
@@ -0,0 +1,78 @@
+package coffee.liz.rookery.importer
+
+import coffee.liz.rookery.model.MemoSession
+import coffee.liz.rookery.model.WordChange
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.contentOrNull
+import kotlinx.serialization.json.doubleOrNull
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.longOrNull
+
+/**
+ * Reads the Letter Pair Gym prototype's `backup.json` (app = "letter-pair-gym", v = 1).
+ *
+ * Known stats fields per pair: n = reps, m = blanks, s = slow, l = recall latencies (ms),
+ * r = recent results oldest→newest (g good, s slow, m miss), ms = total time. `k`, `t`, `x` are
+ * kept verbatim until we know what they mean.
+ */
+object LetterPairGymImport {
+    data class PairStats(val reps: Int, val blanks: Int, val slow: Int, val latenciesMs: List<Long>, val recent: String, val raw: JsonObject)
+
+    data class Result(
+        val words: Map<String, String>,
+        val notes: Map<String, String>,
+        /** pair → path inside the export, e.g. `images/AB - abacus.jpg` */
+        val images: Map<String, String>,
+        val history: List<WordChange>,
+        val stats: Map<String, PairStats>,
+        val memo: List<MemoSession>,
+        /** Raw settings, for the scheme-confirmation step. */
+        val settings: JsonObject?,
+        val exportedAt: String?,
+    )
+
+    private val json = Json { ignoreUnknownKeys = true }
+
+    fun parse(text: String): Result {
+        val root = json.parseToJsonElement(text).jsonObject
+        val app = root.str("app")
+        require(app == "letter-pair-gym") { "not a Letter Pair Gym backup (app = $app)" }
+
+        fun strMap(key: String): Map<String, String> = (root[key] as? JsonObject).orEmpty()
+            .mapNotNull { (k, v) -> (v as? JsonPrimitive)?.contentOrNull?.takeIf { it.isNotBlank() }?.let { k.uppercase() to it.trim() } }
+            .toMap()
+
+        val history = (root["wordHist"] as? JsonArray).orEmpty().mapNotNull { e ->
+            val o = e as? JsonObject ?: return@mapNotNull null
+            WordChange(o.str("p")?.uppercase() ?: return@mapNotNull null, o.str("from"), o.str("to"), o.long("d") ?: 0, "letter-pair-gym")
+        }
+
+        val stats = (root["stats"] as? JsonObject).orEmpty().mapNotNull { (pair, e) ->
+            val o = e as? JsonObject ?: return@mapNotNull null
+            pair.uppercase() to PairStats(
+                reps = o.long("n")?.toInt() ?: 0,
+                blanks = o.long("m")?.toInt() ?: 0,
+                slow = o.long("s")?.toInt() ?: 0,
+                latenciesMs = (o["l"] as? JsonArray).orEmpty().mapNotNull { (it as? JsonPrimitive)?.doubleOrNull?.toLong() },
+                recent = o.str("r").orEmpty(),
+                raw = o,
+            )
+        }.toMap()
+
+        val memo = (root["memoHist"] as? JsonArray).orEmpty().mapNotNull { e ->
+            val o = e as? JsonObject ?: return@mapNotNull null
+            MemoSession(o.long("d") ?: return@mapNotNull null, o.long("p")?.toInt() ?: 0, o.long("ms") ?: 0, o.long("ok")?.toInt() ?: 0)
+        }
+
+        return Result(strMap("words"), strMap("notes"), strMap("images"), history, stats, memo, root["settings"] as? JsonObject, root.str("at"))
+    }
+
+    private fun JsonObject.str(k: String): String? = (this[k] as? JsonPrimitive)?.contentOrNull
+    private fun JsonObject.long(k: String): Long? = (this[k] as? JsonPrimitive)?.let { it.longOrNull ?: it.doubleOrNull?.toLong() }
+}
+
+internal fun JsonElement?.orEmptyObject(): JsonObject = this as? JsonObject ?: JsonObject(emptyMap())
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/model/Domain.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/model/Domain.kt
new file mode 100644
index 0000000..5090ee0
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/model/Domain.kt
@@ -0,0 +1,50 @@
+package coffee.liz.rookery.model
+
+enum class Penalty(val code: String) {
+    NONE("ok"), PLUS2("+2"), DNF("dnf");
+    companion object { fun of(code: String?) = entries.firstOrNull { it.code == code } ?: NONE }
+}
+
+/** Result in ms after penalties; [DNF] sorts after every real time. */
+const val DNF: Long = Long.MAX_VALUE
+
+data class Session(val id: String, val name: String, val event: Event, val createdAt: Long)
+
+data class Solve(
+    val id: String,
+    val sessionId: String,
+    val event: Event,
+    /** Raw timer reading, before penalties. */
+    val ms: Long,
+    val penalty: Penalty,
+    val scramble: String,
+    val comment: String,
+    /** Epoch ms when the solve finished. */
+    val at: Long,
+    /** Smart-cube reconstruction, csTimer style: `R@0 U'@120 ...` */
+    val moves: String? = null,
+) {
+    val result: Long get() = when (penalty) {
+        Penalty.NONE -> ms
+        Penalty.PLUS2 -> ms + 2000
+        Penalty.DNF -> DNF
+    }
+}
+
+data class LetterPair(
+    val pair: String,
+    val primary: String?,
+    val words: Set<String>,
+    val note: String?,
+    /** Blob name of the chosen image. */
+    val image: String?,
+    /** 0 (easy) .. 1 (always missed) from practice history, null if never drilled. */
+    val difficulty: Double? = null,
+)
+
+data class WordChange(val pair: String, val from: String?, val to: String?, val at: Long, val source: String)
+
+data class MemoSession(val at: Long, val pairs: Int, val memoMs: Long, val recalled: Int)
+
+/** A smart cube we have paired with on some device. Synced so every device knows its MAC. */
+data class CubeDevice(val mac: String, val name: String, val protocol: String)
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/model/Event.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/model/Event.kt
new file mode 100644
index 0000000..db7fcb8
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/model/Event.kt
@@ -0,0 +1,37 @@
+package coffee.liz.rookery.model
+
+/** Puzzles the engine knows how to scramble (and, over time, render and simulate). */
+enum class Puzzle { CUBE2, CUBE3, CUBE4, CUBE5, CUBE6, CUBE7, PYRAMINX, SKEWB, MEGAMINX, SQUARE1, CLOCK, FTO;
+    /** Layers per side for NxN puzzles, otherwise null. */
+    val cubeSize: Int? get() = when (this) {
+        CUBE2 -> 2; CUBE3 -> 3; CUBE4 -> 4; CUBE5 -> 5; CUBE6 -> 6; CUBE7 -> 7; else -> null
+    }
+}
+
+/** Events, keyed by WCA event id where one exists. */
+enum class Event(val id: String, val title: String, val short: String, val puzzle: Puzzle, val wca: Boolean = true) {
+    E333("333", "3x3x3", "3x3", Puzzle.CUBE3),
+    E222("222", "2x2x2", "2x2", Puzzle.CUBE2),
+    E444("444", "4x4x4", "4x4", Puzzle.CUBE4),
+    E555("555", "5x5x5", "5x5", Puzzle.CUBE5),
+    E666("666", "6x6x6", "6x6", Puzzle.CUBE6),
+    E777("777", "7x7x7", "7x7", Puzzle.CUBE7),
+    E333BF("333bf", "3x3x3 Blindfolded", "3BLD", Puzzle.CUBE3),
+    E333FM("333fm", "3x3x3 Fewest Moves", "FMC", Puzzle.CUBE3),
+    E333OH("333oh", "3x3x3 One-Handed", "OH", Puzzle.CUBE3),
+    CLOCK("clock", "Clock", "Clock", Puzzle.CLOCK),
+    MINX("minx", "Megaminx", "Mega", Puzzle.MEGAMINX),
+    PYRAM("pyram", "Pyraminx", "Pyra", Puzzle.PYRAMINX),
+    SKEWB("skewb", "Skewb", "Skewb", Puzzle.SKEWB),
+    SQ1("sq1", "Square-1", "Sq-1", Puzzle.SQUARE1),
+    E444BF("444bf", "4x4x4 Blindfolded", "4BLD", Puzzle.CUBE4),
+    E555BF("555bf", "5x5x5 Blindfolded", "5BLD", Puzzle.CUBE5),
+    E333MBF("333mbf", "3x3x3 Multi-Blind", "MBLD", Puzzle.CUBE3),
+    FTO("fto", "Face-Turning Octahedron", "FTO", Puzzle.FTO, wca = false);
+
+    val blind: Boolean get() = this == E333BF || this == E444BF || this == E555BF || this == E333MBF
+
+    companion object {
+        fun byId(id: String): Event? = entries.firstOrNull { it.id == id }
+    }
+}
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/model/Format.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/model/Format.kt
new file mode 100644
index 0000000..923b8da
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/model/Format.kt
@@ -0,0 +1,19 @@
+package coffee.liz.rookery.model
+
+/** `12.34`, `1:02.34`, or `DNF`. Singles truncate to centiseconds, like the WCA does. */
+fun formatTime(ms: Long?, round: Boolean = false): String {
+    if (ms == null) return "-"
+    if (ms == DNF) return "DNF"
+    val cs = if (round) (ms + 5) / 10 else ms / 10
+    val minutes = cs / 6000
+    val seconds = (cs / 100) % 60
+    val hundredths = cs % 100
+    val tail = "." + hundredths.toString().padStart(2, '0')
+    return if (minutes > 0) "$minutes:" + seconds.toString().padStart(2, '0') + tail else "$seconds$tail"
+}
+
+fun formatSolve(s: Solve): String = when (s.penalty) {
+    Penalty.NONE -> formatTime(s.ms)
+    Penalty.PLUS2 -> formatTime(s.ms + 2000) + "+"
+    Penalty.DNF -> "DNF(" + formatTime(s.ms) + ")"
+}
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/puzzle/Geometry.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/puzzle/Geometry.kt
new file mode 100644
index 0000000..9bda5f7
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/puzzle/Geometry.kt
@@ -0,0 +1,60 @@
+package coffee.liz.rookery.puzzle
+
+import kotlin.math.abs
+import kotlin.math.cos
+import kotlin.math.sin
+import kotlin.math.sqrt
+
+data class V3(val x: Double, val y: Double, val z: Double) {
+    operator fun plus(o: V3) = V3(x + o.x, y + o.y, z + o.z)
+    operator fun minus(o: V3) = V3(x - o.x, y - o.y, z - o.z)
+    operator fun times(k: Double) = V3(x * k, y * k, z * k)
+    infix fun dot(o: V3) = x * o.x + y * o.y + z * o.z
+    infix fun cross(o: V3) = V3(y * o.z - z * o.y, z * o.x - x * o.z, x * o.y - y * o.x)
+    val length: Double get() = sqrt(this dot this)
+    fun unit(): V3 = this * (1.0 / length)
+
+    /** Rotate about unit axis [k] by [angle] radians, right-handed (counter-clockwise seen from +k). */
+    fun rotate(k: V3, angle: Double): V3 {
+        val c = cos(angle); val s = sin(angle)
+        return this * c + (k cross this) * s + k * ((k dot this) * (1 - c))
+    }
+
+    companion object { val ZERO = V3(0.0, 0.0, 0.0) }
+}
+
+/** A convex planar polygon, vertices counter-clockwise seen from outside. */
+class Polygon(val points: List<V3>) {
+    val centroid: V3 = points.fold(V3.ZERO) { a, p -> a + p } * (1.0 / points.size)
+    val normal: V3 get() = ((points[1] - points[0]) cross (points[2] - points[0])).unit()
+    val area: Double get() {
+        var acc = V3.ZERO
+        for (i in points.indices) acc += points[i] cross points[(i + 1) % points.size]
+        return acc.length / 2
+    }
+
+    /** Sutherland–Hodgman split by the plane `dot(p, n) = c`: (part above, part below), either may be null. */
+    fun split(n: V3, c: Double, eps: Double = 1e-9): Pair<Polygon?, Polygon?> {
+        val above = mutableListOf<V3>()
+        val below = mutableListOf<V3>()
+        for (i in points.indices) {
+            val a = points[i]; val b = points[(i + 1) % points.size]
+            val da = (a dot n) - c; val db = (b dot n) - c
+            if (da >= -eps) above += a
+            if (da <= eps) below += a
+            if ((da > eps && db < -eps) || (da < -eps && db > eps)) {
+                val p = a + (b - a) * (da / (da - db))
+                above += p; below += p
+            }
+        }
+        fun mk(ps: List<V3>) = if (ps.size >= 3) Polygon(ps).takeIf { it.area > 1e-7 } else null
+        return mk(above) to mk(below)
+    }
+
+    fun map(f: (V3) -> V3) = Polygon(points.map(f))
+
+    /** Shrink toward the centroid, for drawing stickers with plastic showing between them. */
+    fun inset(k: Double) = map { centroid + (it - centroid) * k }
+}
+
+internal fun approxEq(a: V3, b: V3, eps: Double = 1e-6) = abs(a.x - b.x) < eps && abs(a.y - b.y) < eps && abs(a.z - b.z) < eps
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/puzzle/NxnCube.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/puzzle/NxnCube.kt
new file mode 100644
index 0000000..54b4cda
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/puzzle/NxnCube.kt
@@ -0,0 +1,128 @@
+package coffee.liz.rookery.puzzle
+
+/**
+ * Sticker-level model of an NxN cube, enough to draw scramble previews and replay notation.
+ *
+ * Faces are stored U R F D L B (Kociemba order), each n*n stickers row-major as you look at the
+ * face on a standard net. Geometry uses doubled integer coordinates: cubie centres sit on odd/even
+ * steps in [-(n-1), n-1] and stickers poke out to ±n, so quarter turns stay exact integers.
+ * Axes: x→R, y→U, z→F.
+ */
+class NxnCube(val n: Int) {
+    init { require(n in 1..12) }
+
+    enum class Face { U, R, F, D, L, B }
+
+    /** Colour index per sticker slot; the colour index is the face it started on. */
+    val stickers = IntArray(6 * n * n) { it / (n * n) }
+
+    val isSolved: Boolean get() = (0 until 6).all { f -> (0 until n * n).all { stickers[f * n * n + it] == f } }
+
+    fun copy(): NxnCube = NxnCube(n).also { stickers.copyInto(it.stickers) }
+
+    fun apply(alg: String): NxnCube { for (m in Notation.parse(alg, n)) turn(m); return this }
+
+    fun turn(m: Move) {
+        val perm = permutation(m.axis, m.layers, m.quarter)
+        val old = stickers.copyOf()
+        for (i in perm.indices) stickers[perm[i]] = old[i]
+    }
+
+    // ---- geometry ----
+
+    private class P(val x: Int, val y: Int, val z: Int)
+
+    private val positions: Array<P> = Array(6 * n * n) { slotPosition(it) }
+    private val index: Map<Triple<Int, Int, Int>, Int> = positions.withIndex().associate { (i, p) -> Triple(p.x, p.y, p.z) to i }
+
+    private fun slotPosition(slot: Int): P {
+        val face = Face.entries[slot / (n * n)]
+        val r = (slot % (n * n)) / n
+        val c = slot % n
+        val a = 2 * c - (n - 1) // left→right
+        val b = 2 * r - (n - 1) // top→bottom
+        return when (face) {
+            Face.U -> P(a, n, b)
+            Face.D -> P(a, -n, -b)
+            Face.F -> P(a, -b, n)
+            Face.B -> P(-a, -b, -n)
+            Face.R -> P(n, -b, -a)
+            Face.L -> P(-n, -b, a)
+        }
+    }
+
+    private val cache = HashMap<Triple<Int, Set<Int>, Int>, IntArray>()
+
+    /**
+     * Where each slot goes for a turn of [layers] (0 = the +axis face layer, n-1 = the -axis face
+     * layer) about [axis] (0=x,1=y,2=z), clockwise looking from +axis, [quarter] times (1..3).
+     */
+    private fun permutation(axis: Int, layers: Set<Int>, quarter: Int): IntArray = cache.getOrPut(Triple(axis, layers, quarter)) {
+        IntArray(positions.size) { i ->
+            var p = positions[i]
+            val coord = when (axis) { 0 -> p.x; 1 -> p.y; else -> p.z }.coerceIn(-(n - 1), n - 1)
+            val layer = ((n - 1) - coord) / 2
+            if (layer in layers) repeat(quarter) { p = rotate(p, axis) }
+            index.getValue(Triple(p.x, p.y, p.z))
+        }
+    }
+
+    private fun rotate(p: P, axis: Int): P = when (axis) {
+        0 -> P(p.x, p.z, -p.y)
+        1 -> P(-p.z, p.y, p.x)
+        else -> P(p.y, -p.x, p.z)
+    }
+
+    fun face(f: Face): IntArray = stickers.copyOfRange(f.ordinal * n * n, (f.ordinal + 1) * n * n)
+}
+
+/** A turn of a set of layers about an axis, clockwise from the +axis side. */
+data class Move(val axis: Int, val layers: Set<Int>, val quarter: Int)
+
+object Notation {
+    private val token = Regex("""^(\d*)([URFDLBurfdlbxyzMES])(w?)(\d*)('?)$""")
+
+    /** Parse WCA/SiGN notation (R, U2', Rw, 3Rw, r, 2R, x, M…) into layer turns for an n-cube. */
+    fun parse(alg: String, n: Int): List<Move> = alg
+        .replace("(", " ").replace(")", " ")
+        .split(Regex("\\s+")).filter { it.isNotEmpty() }
+        .map { parseMove(it, n) ?: throw IllegalArgumentException("bad move '$it' for ${n}x$n") }
+
+    fun parseMove(t: String, n: Int): Move? {
+        val m = token.matchEntire(t) ?: return null
+        val (prefix, letter, w, amountStr, prime) = m.destructured
+        var amount = if (amountStr.isEmpty()) 1 else amountStr.toInt()
+        if (prime.isNotEmpty()) amount = -amount
+        val all = (0 until n).toSet()
+        val lower = letter[0].isLowerCase() && letter[0] !in "xyz"
+        val face = letter.uppercase()[0]
+        val depth: IntRange = when {
+            face in "XYZ" -> 0 until n
+            face in "MES" -> if (n % 2 == 1 && n > 1) (n / 2)..(n / 2) else return null
+            w.isNotEmpty() || lower -> 0 until (if (prefix.isEmpty()) 2 else prefix.toInt())
+            prefix.isNotEmpty() -> (prefix.toInt() - 1)..(prefix.toInt() - 1)
+            else -> 0..0
+        }
+        if (depth.last >= n) return null
+        // axis, and whether this face sits on the -axis side (so layers count from the other end and direction flips)
+        val (axis, negative) = when (face) {
+            'R', 'X' -> 0 to false; 'L', 'M' -> 0 to true
+            'U', 'Y' -> 1 to false; 'D', 'E' -> 1 to true
+            'F', 'Z', 'S' -> 2 to false; 'B' -> 2 to true
+            else -> return null
+        }
+        val layers = if (face in "XYZ") all else depth.map { if (negative) n - 1 - it else it }.toSet()
+        val q = ((if (negative) -amount else amount) % 4 + 4) % 4
+        return Move(axis, layers, if (q == 0) 4 else q)
+    }
+
+    /** Inverse of a move sequence, as text. */
+    fun invert(alg: String): String = alg.trim().split(Regex("\\s+")).filter { it.isNotEmpty() }.reversed().joinToString(" ") { t ->
+        when {
+            t.endsWith("2'") -> t.dropLast(1)
+            t.endsWith("2") -> t
+            t.endsWith("'") -> t.dropLast(1)
+            else -> "$t'"
+        }
+    }
+}
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/puzzle/Puzzles.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/puzzle/Puzzles.kt
new file mode 100644
index 0000000..3b54f4b
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/puzzle/Puzzles.kt
@@ -0,0 +1,102 @@
+package coffee.liz.rookery.puzzle
+
+import coffee.liz.rookery.model.Puzzle
+import kotlin.math.sqrt
+
+/** Ready-made [TwistyPuzzle]s, each matching tnoodle's (WCA) orientation and notation. */
+object Puzzles {
+    private val cache = HashMap<Puzzle, TwistyPuzzle?>()
+
+    /** The 3D model for [p], or null if it has none yet (Square-1, Clock, FTO, Megaminx). */
+    fun of(p: Puzzle): TwistyPuzzle? = cache.getOrPut(p) {
+        when (p) {
+            Puzzle.CUBE2, Puzzle.CUBE3, Puzzle.CUBE4, Puzzle.CUBE5, Puzzle.CUBE6, Puzzle.CUBE7 -> cube(p.cubeSize!!)
+            Puzzle.PYRAMINX -> pyraminx()
+            Puzzle.SKEWB -> skewb()
+            else -> null
+        }
+    }
+
+    /**
+     * Face colours as 0xRRGGBB, indexed like each puzzle's faces.
+     * Cubes and Skewb: U R F D L B = white red green yellow orange blue (WCA scheme).
+     * Pyraminx: F L R D = green red blue yellow.
+     */
+    fun colors(p: Puzzle): List<Long> = when (p) {
+        Puzzle.PYRAMINX -> listOf(0x2DB84D, 0xE02424, 0x2266E0, 0xFFD500)
+        else -> listOf(0xF4F4F4, 0xE02424, 0x2DB84D, 0xFFD500, 0xFF8A00, 0x2266E0)
+    }.map { it.toLong() }
+
+    private fun tokens(alg: String) = alg.replace("(", " ").replace(")", " ").split(Regex("\\s+")).filter { it.isNotEmpty() }
+
+    // ---- NxN ----
+
+    fun cube(n: Int): TwistyPuzzle {
+        val v = { x: Int, y: Int, z: Int -> V3(x.toDouble(), y.toDouble(), z.toDouble()) }
+        // U R F D L B, counter-clockwise seen from outside
+        val faces = listOf(
+            Polygon(listOf(v(-1, 1, -1), v(-1, 1, 1), v(1, 1, 1), v(1, 1, -1))),
+            Polygon(listOf(v(1, 1, 1), v(1, -1, 1), v(1, -1, -1), v(1, 1, -1))),
+            Polygon(listOf(v(-1, 1, 1), v(-1, -1, 1), v(1, -1, 1), v(1, 1, 1))),
+            Polygon(listOf(v(-1, -1, 1), v(-1, -1, -1), v(1, -1, -1), v(1, -1, 1))),
+            Polygon(listOf(v(-1, 1, -1), v(-1, -1, -1), v(-1, -1, 1), v(-1, 1, 1))),
+            Polygon(listOf(v(1, 1, -1), v(1, -1, -1), v(-1, -1, -1), v(-1, 1, -1))),
+        )
+        val cuts = (1 until n).map { -1.0 + 2.0 * it / n }
+        val axes = listOf(Axis("x", v(1, 0, 0), cuts, 4), Axis("y", v(0, 1, 0), cuts, 4), Axis("z", v(0, 0, 1), cuts, 4))
+        // NxnCube's Notation already speaks "axis 0/1/2, layer 0 = + side, quarter turns clockwise from +axis".
+        return TwistyPuzzle("${n}x$n", faces, axes) { alg ->
+            Notation.parse(alg, n).map { Turn(it.axis, it.layers, it.quarter % 4) }
+        }
+    }
+
+    // ---- Pyraminx: vertex U up, face F towards you ----
+
+    fun pyraminx(): TwistyPuzzle {
+        val r = 2 * sqrt(2.0) / 3
+        val u = V3(0.0, 1.0, 0.0)
+        val l = V3(-r * sqrt(3.0) / 2, -1.0 / 3, r / 2)
+        val rr = V3(r * sqrt(3.0) / 2, -1.0 / 3, r / 2)
+        val b = V3(0.0, -1.0 / 3, -r)
+        val faces = listOf(oriented(u, l, rr), oriented(u, b, l), oriented(u, rr, b), oriented(l, b, rr))
+        // Opposite faces sit at -1/3 along each vertex axis; thirds of the height give tips and middles.
+        val cuts = listOf(1.0 / 9, 5.0 / 9)
+        val axes = listOf(Axis("U", u, cuts, 3), Axis("L", l, cuts, 3), Axis("R", rr, cuts, 3), Axis("B", b, cuts, 3))
+        return TwistyPuzzle("pyraminx", faces, axes) { alg ->
+            tokens(alg).map { t ->
+                val m = Regex("""^([ULRBulrb])(')?$""").matchEntire(t) ?: throw IllegalArgumentException("bad pyraminx move '$t'")
+                val c = m.groupValues[1][0]
+                val axis = "ULRB".indexOf(c.uppercaseChar())
+                Turn(axis, if (c.isLowerCase()) setOf(0) else setOf(0, 1), if (m.groupValues[2].isEmpty()) 1 else 2)
+            }
+        }
+    }
+
+    // ---- Skewb (WCA notation: R = DRB corner, U = ULB, L = DLF, B = DLB) ----
+
+    fun skewb(): TwistyPuzzle {
+        val cubeFaces = cube(1)
+        val k = 1 / sqrt(3.0)
+        fun corner(x: Int, y: Int, z: Int) = V3(x * k, y * k, z * k)
+        val axes = listOf(
+            Axis("R", corner(1, -1, -1), listOf(0.0), 3),
+            Axis("U", corner(-1, 1, -1), listOf(0.0), 3),
+            Axis("L", corner(-1, -1, 1), listOf(0.0), 3),
+            Axis("B", corner(-1, -1, -1), listOf(0.0), 3),
+        )
+        return TwistyPuzzle("skewb", cubeFaces.faces(), axes) { alg ->
+            tokens(alg).map { t ->
+                val m = Regex("""^([RULB])(')?$""").matchEntire(t) ?: throw IllegalArgumentException("bad skewb move '$t'")
+                Turn("RULB".indexOf(m.groupValues[1][0]), setOf(0), if (m.groupValues[2].isEmpty()) 1 else 2)
+            }
+        }
+    }
+
+    /** Re-derive whole (uncut) faces from a 1x1 model. */
+    private fun TwistyPuzzle.faces(): List<Polygon> = stickers
+
+    private fun oriented(a: V3, b: V3, c: V3): Polygon {
+        val p = Polygon(listOf(a, b, c))
+        return if ((p.normal dot p.centroid) > 0) p else Polygon(listOf(a, c, b))
+    }
+}
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/puzzle/TwistyPuzzle.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/puzzle/TwistyPuzzle.kt
new file mode 100644
index 0000000..cdb8d85
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/puzzle/TwistyPuzzle.kt
@@ -0,0 +1,91 @@
+package coffee.liz.rookery.puzzle
+
+import kotlin.math.PI
+
+/**
+ * A turning axis: unit [normal], parallel cut planes at signed distances [cuts], and the rotational
+ * order of a turn (4 for cubes, 3 for tetra/octa/corner-turners, 5 for dodecahedra).
+ *
+ * Slabs are numbered from the +normal side: slab 0 lies beyond the largest cut.
+ */
+class Axis(val name: String, val normal: V3, cuts: List<Double>, val order: Int) {
+    val cuts: List<Double> = cuts.sortedDescending()
+    fun slabOf(p: V3): Int { val d = p dot normal; return cuts.count { it > d } }
+    val slabs: Int get() = cuts.size + 1
+}
+
+/** Rotate [layers] of [axis] by [amount] steps of 2π/order, clockwise as seen from the +normal side. */
+data class Turn(val axis: Int, val layers: Set<Int>, val amount: Int)
+
+/**
+ * Any "polyhedron cut by planes" twisty puzzle. Stickers are the face polygons clipped by every
+ * cut plane; a turn permutes sticker slots. State is just a colour per slot (see [PuzzleState]).
+ */
+class TwistyPuzzle(
+    val name: String,
+    faces: List<Polygon>,
+    val axes: List<Axis>,
+    /** Parses this puzzle's notation into turns; throws on unknown moves. */
+    private val notation: (String) -> List<Turn>,
+) {
+    val stickers: List<Polygon>
+    /** Which original face (= colour index) each slot belongs to when solved. */
+    val stickerFace: IntArray
+    val faceCount: Int = faces.size
+
+    init {
+        val out = mutableListOf<Polygon>()
+        val faceOf = mutableListOf<Int>()
+        for ((fi, face) in faces.withIndex()) {
+            var parts = listOf(face)
+            for (axis in axes) for (c in axis.cuts) {
+                parts = parts.flatMap { p -> p.split(axis.normal, c).toList().filterNotNull() }
+            }
+            out += parts; repeat(parts.size) { faceOf += fi }
+        }
+        stickers = out
+        stickerFace = faceOf.toIntArray()
+    }
+
+    private val slab: Array<IntArray> = Array(axes.size) { a -> IntArray(stickers.size) { axes[a].slabOf(stickers[it].centroid) } }
+
+    fun slabOf(axis: Int, sticker: Int): Int = slab[axis][sticker]
+
+    private val perms = HashMap<Turn, IntArray>()
+
+    /** perm[i] = slot that the sticker at slot i moves to. */
+    fun permutation(t: Turn): IntArray = perms.getOrPut(t) {
+        val axis = axes[t.axis]
+        val angle = -2 * PI * t.amount / axis.order
+        IntArray(stickers.size) { i ->
+            if (slab[t.axis][i] !in t.layers) i
+            else {
+                val target = stickers[i].centroid.rotate(axis.normal, angle)
+                var best = -1; var bestD = Double.MAX_VALUE
+                for (j in stickers.indices) {
+                    val d = (stickers[j].centroid - target).length
+                    if (d < bestD) { bestD = d; best = j }
+                }
+                check(bestD < 1e-6) { "$name: turn $t doesn't map sticker $i onto a sticker (off by $bestD)" }
+                best
+            }
+        }
+    }
+
+    fun parse(alg: String): List<Turn> = notation(alg)
+
+    fun solved(): PuzzleState = PuzzleState(this, stickerFace.copyOf())
+}
+
+class PuzzleState(val puzzle: TwistyPuzzle, val colors: IntArray) {
+    fun apply(t: Turn): PuzzleState {
+        val p = puzzle.permutation(t)
+        val next = IntArray(colors.size)
+        for (i in colors.indices) next[p[i]] = colors[i]
+        return PuzzleState(puzzle, next)
+    }
+
+    fun apply(alg: String): PuzzleState = puzzle.parse(alg).fold(this) { s, t -> s.apply(t) }
+
+    val isSolved: Boolean get() = colors.contentEquals(puzzle.stickerFace)
+}
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/scramble/Scrambler.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/scramble/Scrambler.kt
new file mode 100644
index 0000000..b056e91
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/scramble/Scrambler.kt
@@ -0,0 +1,14 @@
+package coffee.liz.rookery.scramble
+
+import coffee.liz.rookery.model.Event
+
+interface Scrambler {
+    /** A fresh scramble. May block while solver tables warm up; call off the UI thread. */
+    fun next(event: Event): String
+
+    /** An SVG drawing of the scrambled puzzle, or null if unavailable. */
+    fun previewSvg(event: Event, scramble: String): String?
+
+    /** Start building solver tables / a scramble ahead of time. */
+    fun warm(event: Event) {}
+}
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/stats/Stats.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/stats/Stats.kt
new file mode 100644
index 0000000..59a2a93
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/stats/Stats.kt
@@ -0,0 +1,95 @@
+package coffee.liz.rookery.stats
+
+import coffee.liz.rookery.model.DNF
+
+/** Averages the way the WCA (and csTimer) compute them. Inputs are results in ms, [DNF] for DNFs. */
+object Averages {
+    /** Solves trimmed from each end of an average of [n]: 1 for ao5/ao12, 5% beyond that. */
+    fun trim(n: Int): Int = if (n < 5) 0 else maxOf(1, (n + 19) / 20)
+
+    /** Trimmed mean of a window of results; DNF if more DNFs than the trim allows. */
+    fun average(window: List<Long>): Long {
+        if (window.isEmpty()) return DNF
+        val sorted = window.sorted()
+        return trimmedMean(sorted, trim(window.size))
+    }
+
+    /** Plain mean; any DNF makes it DNF. Used for mo3. */
+    fun mean(window: List<Long>): Long =
+        if (window.isEmpty() || window.any { it == DNF }) DNF else window.sum() / window.size
+
+    private fun trimmedMean(sorted: List<Long>, t: Int): Long {
+        val kept = sorted.subList(t, sorted.size - t)
+        if (kept.any { it == DNF }) return DNF
+        return (kept.sum() + kept.size / 2) / kept.size
+    }
+
+    /**
+     * Best aoN (or moN when [mean]) over all windows, oldest first. O(len * n), fine up to ao1000
+     * on six-figure solve counts.
+     */
+    fun best(results: List<Long>, n: Int, mean: Boolean = false): Long? {
+        if (results.size < n) return null
+        val window = ArrayList<Long>(n + 1)
+        var best = DNF
+        for ((i, r) in results.withIndex()) {
+            window.add(lowerBound(window, r), r)
+            if (i >= n) window.removeAt(lowerBound(window, results[i - n]))
+            if (i >= n - 1) {
+                val v = if (mean) (if (window.last() == DNF) DNF else window.sum() / n) else trimmedMean(window, trim(n))
+                if (v < best) best = v
+            }
+        }
+        return best
+    }
+
+    private fun lowerBound(xs: List<Long>, v: Long): Int {
+        var lo = 0; var hi = xs.size
+        while (lo < hi) { val m = (lo + hi) ushr 1; if (xs[m] < v) lo = m + 1 else hi = m }
+        return lo
+    }
+}
+
+enum class StatKind(val label: String, val n: Int, val mean: Boolean = false) {
+    SINGLE("single", 1), MO3("mo3", 3, true), AO5("ao5", 5), AO12("ao12", 12), AO50("ao50", 50), AO100("ao100", 100), AO1000("ao1000", 1000);
+}
+
+data class StatLine(val kind: StatKind, val current: Long?, val best: Long?)
+
+/** Summary of a chronological list of results. */
+data class StatSummary(val count: Int, val solved: Int, val mean: Long?, val lines: List<StatLine>) {
+    fun line(k: StatKind): StatLine? = lines.firstOrNull { it.kind == k }
+
+    companion object {
+        fun of(results: List<Long>): StatSummary {
+            val solved = results.filter { it != DNF }
+            val lines = StatKind.entries.mapNotNull { k ->
+                if (results.size < k.n) return@mapNotNull null
+                val last = results.subList(results.size - k.n, results.size)
+                val current = when {
+                    k == StatKind.SINGLE -> last[0]
+                    k.mean -> Averages.mean(last)
+                    else -> Averages.average(last)
+                }
+                val best = if (k == StatKind.SINGLE) results.min() else Averages.best(results, k.n, k.mean)
+                StatLine(k, current, best)
+            }
+            return StatSummary(results.size, solved.size, if (solved.isEmpty()) null else solved.sum() / solved.size, lines)
+        }
+    }
+}
+
+/** A personal best set by the most recent solve. */
+data class PersonalBest(val kind: StatKind, val value: Long, val previous: Long?)
+
+/**
+ * PBs earned by appending one solve: the new current value strictly beats the best from before.
+ * Only meaningful right after an add; edits to old solves don't throw parties.
+ */
+fun newPersonalBests(before: StatSummary, after: StatSummary): List<PersonalBest> =
+    after.lines.mapNotNull { line ->
+        val cur = line.current ?: return@mapNotNull null
+        if (cur == DNF) return@mapNotNull null
+        val prev = before.line(line.kind)?.best
+        if (prev == null || cur < prev) PersonalBest(line.kind, cur, prev) else null
+    }
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/store/Hlc.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/store/Hlc.kt
new file mode 100644
index 0000000..c4750ed
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/store/Hlc.kt
@@ -0,0 +1,39 @@
+package coffee.liz.rookery.store
+
+/**
+ * Hybrid logical clock timestamp. Totally ordered: wall time, then counter, then node id,
+ * so two devices can never produce equal stamps. The string form sorts the same way.
+ */
+data class Hlc(val wall: Long, val counter: Int, val node: String) : Comparable<Hlc> {
+    override fun compareTo(other: Hlc): Int =
+        compareValuesBy(this, other, Hlc::wall, Hlc::counter, Hlc::node)
+
+    override fun toString(): String =
+        wall.toString().padStart(13, '0') + "-" + counter.toString(16).padStart(4, '0') + "-" + node
+
+    companion object {
+        fun parse(s: String): Hlc {
+            val a = s.indexOf('-')
+            val b = s.indexOf('-', a + 1)
+            require(a > 0 && b > a) { "bad hlc: $s" }
+            return Hlc(s.substring(0, a).toLong(), s.substring(a + 1, b).toInt(16), s.substring(b + 1))
+        }
+    }
+}
+
+class HlcClock(private val node: String, private val now: () -> Long) {
+    private var last = Hlc(0, 0, node)
+
+    fun tick(): Hlc {
+        val wall = now()
+        last = if (wall > last.wall) Hlc(wall, 0, node) else Hlc(last.wall, last.counter + 1, node)
+        return last
+    }
+
+    /** Fold in a remote stamp so our next tick sorts after everything we have seen. */
+    fun observe(remote: Hlc) {
+        if (remote.wall > last.wall || (remote.wall == last.wall && remote.counter > last.counter)) {
+            last = Hlc(remote.wall, remote.counter, node)
+        }
+    }
+}
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/store/Op.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/store/Op.kt
new file mode 100644
index 0000000..5c74fb0
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/store/Op.kt
@@ -0,0 +1,26 @@
+package coffee.liz.rookery.store
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonElement
+
+/**
+ * One last-writer-wins assignment: collection/id/field := value, stamped with an HLC.
+ * Every piece of synced state is built from these, which makes merging a plain union:
+ * apply every op from every device in any order and all replicas converge.
+ *
+ * Conventions:
+ *  - `_del` = true tombstones an entity.
+ *  - Set-like data uses one field per element (e.g. `w:penguin` = true/false).
+ */
+@Serializable
+data class Op(val t: String, val c: String, val id: String, val f: String, val v: JsonElement) {
+    val hlc: Hlc get() = Hlc.parse(t)
+
+    fun encode(): String = json.encodeToString(serializer(), this)
+
+    companion object {
+        val json = Json { ignoreUnknownKeys = true }
+        fun decode(line: String): Op? = runCatching { json.decodeFromString(serializer(), line) }.getOrNull()
+    }
+}
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/store/Replica.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/store/Replica.kt
new file mode 100644
index 0000000..46685fb
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/store/Replica.kt
@@ -0,0 +1,32 @@
+package coffee.liz.rookery.store
+
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.booleanOrNull
+
+/** Materialized LWW state: collection -> id -> field -> (stamp, value). */
+class Replica {
+    class Cell(val t: String, val v: JsonElement)
+
+    private val data = HashMap<String, HashMap<String, HashMap<String, Cell>>>()
+
+    /** Returns true if the op changed visible state. */
+    fun apply(op: Op): Boolean {
+        val fields = data.getOrPut(op.c) { HashMap() }.getOrPut(op.id) { HashMap() }
+        val cur = fields[op.f]
+        // Stamps are fixed-width-prefixed strings that sort like the Hlc itself.
+        if (cur != null && Hlc.parse(cur.t) >= op.hlc) return false
+        fields[op.f] = Cell(op.t, op.v)
+        return true
+    }
+
+    /** Live (non-tombstoned) entities in a collection. */
+    fun entities(c: String): Map<String, Map<String, JsonElement>> =
+        data[c].orEmpty()
+            .filterValues { f -> (f["_del"]?.v as? JsonPrimitive)?.booleanOrNull != true }
+            .mapValues { (_, f) -> f.mapValues { it.value.v } }
+
+    fun entity(c: String, id: String): Map<String, JsonElement>? = entities(c)[id]
+
+    fun fieldStamp(c: String, id: String, f: String): String? = data[c]?.get(id)?.get(f)?.t
+}
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/store/Repo.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/store/Repo.kt
new file mode 100644
index 0000000..6c0fafa
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/store/Repo.kt
@@ -0,0 +1,166 @@
+package coffee.liz.rookery.store
+
+import coffee.liz.rookery.model.CubeDevice
+import coffee.liz.rookery.model.Event
+import coffee.liz.rookery.model.LetterPair
+import coffee.liz.rookery.model.MemoSession
+import coffee.liz.rookery.model.Penalty
+import coffee.liz.rookery.model.Session
+import coffee.liz.rookery.model.Solve
+import coffee.liz.rookery.model.WordChange
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonNull
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.booleanOrNull
+import kotlinx.serialization.json.contentOrNull
+import kotlinx.serialization.json.longOrNull
+
+/** Collection names in the op log. Renaming one is a data migration, so they stay short and fixed. */
+object Coll {
+    const val SESSION = "session"
+    const val SOLVE = "solve"
+    const val PAIR = "pair"
+    const val PAIR_HISTORY = "pairHist"
+    const val MEMO = "memo"
+    const val DEVICE = "device"
+    const val PREFS = "prefs"
+}
+
+private fun Map<String, JsonElement>.str(f: String): String? = (this[f] as? JsonPrimitive)?.takeIf { this[f] !is JsonNull }?.contentOrNull
+private fun Map<String, JsonElement>.long(f: String): Long? = (this[f] as? JsonPrimitive)?.longOrNull
+private fun Map<String, JsonElement>.bool(f: String): Boolean? = (this[f] as? JsonPrimitive)?.booleanOrNull
+
+/** Typed reads and writes over the [Store]. */
+class Repo(val store: Store) {
+
+    // ---- sessions & solves ----
+
+    fun sessions(): List<Session> = store.read { r ->
+        r.entities(Coll.SESSION).mapNotNull { (id, f) ->
+            val event = Event.byId(f.str("event") ?: return@mapNotNull null) ?: return@mapNotNull null
+            Session(id, f.str("name") ?: event.short, event, f.long("created") ?: 0)
+        }.sortedBy { it.createdAt }
+    }
+
+    fun solves(): List<Solve> = store.read { r ->
+        r.entities(Coll.SOLVE).mapNotNull { (id, f) ->
+            Solve(
+                id = id,
+                sessionId = f.str("session") ?: return@mapNotNull null,
+                event = Event.byId(f.str("event") ?: return@mapNotNull null) ?: return@mapNotNull null,
+                ms = f.long("ms") ?: return@mapNotNull null,
+                penalty = Penalty.of(f.str("pen")),
+                scramble = f.str("scr").orEmpty(),
+                comment = f.str("note").orEmpty(),
+                at = f.long("at") ?: 0,
+                moves = f.str("moves"),
+            )
+        }.sortedWith(compareBy({ it.at }, { it.id }))
+    }
+
+    fun createSession(id: String, name: String, event: Event, createdAt: Long) = store.transact {
+        set(Coll.SESSION, id, "name", name)
+        set(Coll.SESSION, id, "event", event.id)
+        set(Coll.SESSION, id, "created", createdAt)
+    }
+
+    fun renameSession(id: String, name: String) = store.transact { set(Coll.SESSION, id, "name", name) }
+
+    fun deleteSession(id: String) {
+        val doomed = solves().filter { it.sessionId == id }
+        store.transact {
+            delete(Coll.SESSION, id)
+            for (s in doomed) delete(Coll.SOLVE, s.id)
+        }
+    }
+
+    fun addSolve(s: Solve) = store.transact { writeSolve(s) }
+
+    fun Store.Tx.writeSolve(s: Solve) {
+        set(Coll.SOLVE, s.id, "session", s.sessionId)
+        set(Coll.SOLVE, s.id, "event", s.event.id)
+        set(Coll.SOLVE, s.id, "ms", s.ms)
+        set(Coll.SOLVE, s.id, "pen", s.penalty.code)
+        set(Coll.SOLVE, s.id, "scr", s.scramble)
+        if (s.comment.isNotEmpty()) set(Coll.SOLVE, s.id, "note", s.comment)
+        set(Coll.SOLVE, s.id, "at", s.at)
+        if (s.moves != null) set(Coll.SOLVE, s.id, "moves", s.moves)
+    }
+
+    fun setPenalty(id: String, p: Penalty) = store.transact { set(Coll.SOLVE, id, "pen", p.code) }
+    fun setComment(id: String, note: String) = store.transact { set(Coll.SOLVE, id, "note", note) }
+    fun deleteSolve(id: String) = store.transact { delete(Coll.SOLVE, id) }
+
+    // ---- letter pairs ----
+
+    fun letterPairs(): Map<String, LetterPair> = store.read { r ->
+        r.entities(Coll.PAIR).mapValues { (pair, f) ->
+            LetterPair(
+                pair = pair,
+                primary = f.str("primary"),
+                words = f.filter { (k, v) -> k.startsWith("w:") && (v as? JsonPrimitive)?.booleanOrNull == true }
+                    .keys.map { it.removePrefix("w:") }.toSet(),
+                note = f.str("note"),
+                image = f.str("image"),
+                difficulty = difficulty(f["gymStats"]),
+            )
+        }
+    }
+
+    /** Make [word] the main word for [pair], keeping it in the pair's word set. Logs the change. */
+    fun setPrimaryWord(pair: String, word: String, at: Long, source: String = "edit") {
+        val old = letterPairs()[pair]?.primary
+        if (old == word) return
+        store.transact {
+            set(Coll.PAIR, pair, "primary", word)
+            set(Coll.PAIR, pair, "w:$word", true)
+            set(Coll.PAIR_HISTORY, coffee.liz.rookery.util.fnv64(pair, old.orEmpty(), word, at.toString()), "v",
+                historyJson(WordChange(pair, old, word, at, source)))
+        }
+    }
+
+    fun setPairNote(pair: String, note: String?) = store.transact { set(Coll.PAIR, pair, "note", note) }
+    fun setPairImage(pair: String, blob: String?) = store.transact { set(Coll.PAIR, pair, "image", blob) }
+    fun setWordInSet(pair: String, word: String, present: Boolean) = store.transact { set(Coll.PAIR, pair, "w:$word", present) }
+
+    fun wordHistory(): List<WordChange> = store.read { r ->
+        r.entities(Coll.PAIR_HISTORY).values.mapNotNull { f -> f["v"]?.let(::parseHistory) }
+    }.sortedByDescending { it.at }
+
+    fun memoSessions(): List<MemoSession> = store.read { r ->
+        r.entities(Coll.MEMO).values.mapNotNull { f ->
+            MemoSession(f.long("at") ?: return@mapNotNull null, f.long("pairs")?.toInt() ?: 0, f.long("ms") ?: 0, f.long("ok")?.toInt() ?: 0)
+        }
+    }.sortedBy { it.at }
+
+    // ---- devices & prefs ----
+
+    fun devices(): List<CubeDevice> = store.read { r ->
+        r.entities(Coll.DEVICE).map { (mac, f) -> CubeDevice(mac, f.str("name") ?: mac, f.str("proto") ?: "unknown") }
+    }
+
+    fun pref(key: String): String? = store.read { r -> r.entity(Coll.PREFS, "global")?.str(key) }
+    fun boolPref(key: String, default: Boolean): Boolean =
+        store.read { r -> r.entity(Coll.PREFS, "global")?.bool(key) } ?: default
+    fun setPref(key: String, value: String?) = store.transact { set(Coll.PREFS, "global", key, value) }
+    fun setPref(key: String, value: Boolean) = store.transact { set(Coll.PREFS, "global", key, value) }
+
+    companion object {
+        /** Share of recent attempts that were slow (half weight) or missed (full weight). */
+        private fun difficulty(e: JsonElement?): Double? {
+            val recent = ((e as? kotlinx.serialization.json.JsonObject)?.get("r") as? JsonPrimitive)?.contentOrNull ?: return null
+            if (recent.isEmpty()) return null
+            return recent.sumOf { c -> when (c) { 'm' -> 1.0; 's' -> 0.5; else -> 0.0 } } / recent.length
+        }
+
+        internal fun historyJson(w: WordChange): JsonElement = kotlinx.serialization.json.buildJsonObject {
+            put("pair", JsonPrimitive(w.pair)); put("from", JsonPrimitive(w.from)); put("to", JsonPrimitive(w.to))
+            put("at", JsonPrimitive(w.at)); put("src", JsonPrimitive(w.source))
+        }
+
+        private fun parseHistory(e: JsonElement): WordChange? {
+            val o = e as? kotlinx.serialization.json.JsonObject ?: return null
+            return WordChange(o.str("pair") ?: return null, o.str("from"), o.str("to"), o.long("at") ?: 0, o.str("src") ?: "edit")
+        }
+    }
+}
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/store/Storage.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/store/Storage.kt
new file mode 100644
index 0000000..7049549
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/store/Storage.kt
@@ -0,0 +1,36 @@
+package coffee.liz.rookery.store
+
+/**
+ * Where op lines live. The contract that makes dumb file sync (Syncthing, Drive, a USB stick) safe:
+ * a device only ever appends to its own log files, and readers tolerate a torn final line.
+ */
+interface LogStorage {
+    /** Append lines (no trailing newlines) to this device's log, durably, in one write. */
+    fun append(lines: List<String>)
+
+    /** Lines from any device's log that this reader has not returned before. */
+    fun readNew(): List<String>
+}
+
+/** Content-addressed binary storage (images), synced alongside the log. */
+interface BlobStore {
+    /** Stores bytes and returns their name, `<sha256>.<ext>`. Idempotent. */
+    fun put(bytes: ByteArray, ext: String): String
+    fun get(name: String): ByteArray?
+}
+
+class MemoryLogStorage(private val shared: MutableList<String> = mutableListOf()) : LogStorage {
+    private var read = 0
+    override fun append(lines: List<String>) { shared.addAll(lines) }
+    override fun readNew(): List<String> = shared.subList(read, shared.size).toList().also { read = shared.size }
+}
+
+class MemoryBlobStore : BlobStore {
+    private val blobs = HashMap<String, ByteArray>()
+    override fun put(bytes: ByteArray, ext: String): String {
+        val name = coffee.liz.rookery.util.fnv64(bytes) + "." + ext
+        blobs[name] = bytes
+        return name
+    }
+    override fun get(name: String) = blobs[name]
+}
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/store/Store.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/store/Store.kt
new file mode 100644
index 0000000..7873b76
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/store/Store.kt
@@ -0,0 +1,61 @@
+package coffee.liz.rookery.store
+
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonPrimitive
+
+/** The synced database: an HLC, a replica, and a log to persist ops to. Thread-confined via [lock]. */
+class Store(
+    val nodeId: String,
+    private val log: LogStorage,
+    val blobs: BlobStore,
+    now: () -> Long,
+) {
+    private val clock = HlcClock(nodeId, now)
+    private val replica = Replica()
+    private val lock = Any()
+    private val _version = MutableStateFlow(0L)
+
+    /** Bumps whenever visible state changes; UI re-derives from the replica when it does. */
+    val version: StateFlow<Long> = _version.asStateFlow()
+
+    init { sync() }
+
+    class Tx internal constructor(private val clock: HlcClock) {
+        internal val ops = mutableListOf<Op>()
+        fun set(c: String, id: String, f: String, v: JsonElement) {
+            ops += Op(clock.tick().toString(), c, id, f, v)
+        }
+        fun set(c: String, id: String, f: String, v: String?) = set(c, id, f, JsonPrimitive(v))
+        fun set(c: String, id: String, f: String, v: Number) = set(c, id, f, JsonPrimitive(v))
+        fun set(c: String, id: String, f: String, v: Boolean) = set(c, id, f, JsonPrimitive(v))
+        fun delete(c: String, id: String) = set(c, id, "_del", true)
+    }
+
+    fun transact(block: Tx.() -> Unit) {
+        coffee.liz.rookery.locked(lock) {
+            val tx = Tx(clock).apply(block)
+            if (tx.ops.isEmpty()) return@locked
+            log.append(tx.ops.map { it.encode() })
+            var changed = false
+            for (op in tx.ops) changed = replica.apply(op) || changed
+            if (changed) _version.value++
+        }
+    }
+
+    /** Pull ops other devices wrote since last time. Returns how many changed state. */
+    fun sync(): Int = coffee.liz.rookery.locked(lock) {
+        var changed = 0
+        for (line in log.readNew()) {
+            val op = Op.decode(line) ?: continue
+            clock.observe(op.hlc)
+            if (replica.apply(op)) changed++
+        }
+        if (changed > 0) _version.value++
+        changed
+    }
+
+    fun <T> read(block: (Replica) -> T): T = coffee.liz.rookery.locked(lock) { block(replica) }
+}
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/timer/TimerMachine.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/timer/TimerMachine.kt
new file mode 100644
index 0000000..f08a550
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/timer/TimerMachine.kt
@@ -0,0 +1,80 @@
+package coffee.liz.rookery.timer
+
+import coffee.liz.rookery.model.Penalty
+
+/**
+ * The spacebar/touch timer as a pure state machine. The UI feeds it press/release/tick with a
+ * monotonic clock and renders [state]; nothing in here touches real time.
+ */
+class TimerMachine(var inspection: Boolean = true, var holdMs: Long = 300) {
+    sealed interface State {
+        data object Idle : State
+        data class Inspecting(val since: Long) : State
+        /** Finger down, waiting for the hold time. [inspectingSince] carries over inspection. */
+        data class Holding(val since: Long, val inspectingSince: Long?) : State
+        data class Ready(val inspectingSince: Long?) : State
+        data class Running(val since: Long, val penalty: Penalty) : State
+        data class Stopped(val ms: Long, val penalty: Penalty, val awaitingRelease: Boolean) : State
+    }
+
+    var state: State = State.Idle
+        private set
+
+    /** Fired once per finished solve. */
+    var onFinish: (ms: Long, penalty: Penalty) -> Unit = { _, _ -> }
+
+    fun press(now: Long) {
+        state = when (val s = state) {
+            State.Idle -> State.Holding(now, null)
+            is State.Stopped -> if (s.awaitingRelease) s else State.Holding(now, null)
+            is State.Inspecting -> State.Holding(now, s.since)
+            is State.Running -> {
+                val ms = now - s.since
+                onFinish(ms, s.penalty)
+                State.Stopped(ms, s.penalty, awaitingRelease = true)
+            }
+            is State.Holding, is State.Ready -> s
+        }
+    }
+
+    fun release(now: Long) {
+        state = when (val s = state) {
+            is State.Holding -> when {
+                s.inspectingSince != null -> State.Inspecting(s.inspectingSince) // let go early: keep inspecting
+                inspection -> State.Inspecting(now)
+                else -> State.Idle
+            }
+            is State.Ready -> State.Running(now, inspectionPenalty(s.inspectingSince, now))
+            is State.Stopped -> s.copy(awaitingRelease = false)
+            else -> s
+        }
+    }
+
+    fun tick(now: Long) {
+        val s = state
+        if (s is State.Holding && now - s.since >= holdMs && (s.inspectingSince != null || !inspection)) {
+            state = State.Ready(s.inspectingSince)
+        }
+        if (s is State.Inspecting && now - s.since > INSPECTION_DNF_MS) {
+            onFinish(0, Penalty.DNF)
+            state = State.Stopped(0, Penalty.DNF, awaitingRelease = false)
+        }
+    }
+
+    fun cancel() { state = State.Idle }
+
+    private fun inspectionPenalty(since: Long?, now: Long): Penalty {
+        if (since == null) return Penalty.NONE
+        val t = now - since
+        return when {
+            t > INSPECTION_DNF_MS -> Penalty.DNF
+            t > INSPECTION_MS -> Penalty.PLUS2
+            else -> Penalty.NONE
+        }
+    }
+
+    companion object {
+        const val INSPECTION_MS = 15_000L
+        const val INSPECTION_DNF_MS = 17_000L
+    }
+}
diff --git a/core/src/commonMain/kotlin/coffee/liz/rookery/util/Hash.kt b/core/src/commonMain/kotlin/coffee/liz/rookery/util/Hash.kt
new file mode 100644
index 0000000..8c7c447
--- /dev/null
+++ b/core/src/commonMain/kotlin/coffee/liz/rookery/util/Hash.kt
@@ -0,0 +1,20 @@
+package coffee.liz.rookery.util
+
+/** FNV-1a 64-bit, hex encoded. Used for deterministic ids so re-imports are idempotent. */
+fun fnv64(vararg parts: String): String {
+    var h = -0x340d631b7bdddcdbL // 0xcbf29ce484222325
+    for ((i, p) in parts.withIndex()) {
+        if (i > 0) { h = h xor 0x1f; h *= 0x100000001b3L }
+        for (b in p.encodeToByteArray()) {
+            h = h xor (b.toLong() and 0xff)
+            h *= 0x100000001b3L
+        }
+    }
+    return h.toULong().toString(16).padStart(16, '0')
+}
+
+fun fnv64(bytes: ByteArray): String {
+    var h = -0x340d631b7bdddcdbL
+    for (b in bytes) { h = h xor (b.toLong() and 0xff); h *= 0x100000001b3L }
+    return h.toULong().toString(16).padStart(16, '0')
+}
diff --git a/core/src/commonTest/kotlin/coffee/liz/rookery/ChimeTest.kt b/core/src/commonTest/kotlin/coffee/liz/rookery/ChimeTest.kt
new file mode 100644
index 0000000..7ab195c
--- /dev/null
+++ b/core/src/commonTest/kotlin/coffee/liz/rookery/ChimeTest.kt
@@ -0,0 +1,14 @@
+package coffee.liz.rookery
+
+import coffee.liz.rookery.audio.Chime
+import kotlin.test.Test
+import kotlin.test.assertTrue
+
+class ChimeTest {
+    @Test fun rendersAudibleShortJingle() {
+        val pcm = Chime.render(Chime.PB)
+        val seconds = pcm.size.toDouble() / Chime.SAMPLE_RATE
+        assertTrue(seconds in 0.8..3.0, "length $seconds")
+        assertTrue(pcm.maxOf { it.toInt() } > 3000)
+    }
+}
diff --git a/core/src/commonTest/kotlin/coffee/liz/rookery/CubeTest.kt b/core/src/commonTest/kotlin/coffee/liz/rookery/CubeTest.kt
new file mode 100644
index 0000000..829049e
--- /dev/null
+++ b/core/src/commonTest/kotlin/coffee/liz/rookery/CubeTest.kt
@@ -0,0 +1,55 @@
+package coffee.liz.rookery
+
+import coffee.liz.rookery.puzzle.NxnCube
+import coffee.liz.rookery.puzzle.Notation
+import kotlin.test.Test
+import kotlin.test.assertContentEquals
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class CubeTest {
+    @Test fun basicIdentities() {
+        for (n in 2..7) {
+            assertTrue(NxnCube(n).apply("R R R R").isSolved)
+            assertTrue(NxnCube(n).apply("R U R' U' R U R' U' R U R' U' R U R' U' R U R' U' R U R' U'").isSolved, "sexy^6 on $n")
+            assertFalse(NxnCube(n).apply("R U").isSolved)
+        }
+    }
+
+    @Test fun scrambleThenInverseSolves() {
+        val scr = "3Rw2 Uw' F 3Fw D2 Lw' B2 x y' 2R 3Uw2 z M"
+        val c = NxnCube(7).apply(scr)
+        assertFalse(c.isSolved)
+        c.apply(Notation.invert(scr))
+        assertTrue(c.isSolved)
+    }
+
+    @Test fun rMovesFrontToUp() {
+        val c = NxnCube(3).apply("R")
+        // U face right column now shows F's colour (index 2)
+        assertEquals(listOf(0, 0, 2, 0, 0, 2, 0, 0, 2), c.face(NxnCube.Face.U).toList())
+        // F face right column shows D (3)
+        assertEquals(listOf(2, 2, 3, 2, 2, 3, 2, 2, 3), c.face(NxnCube.Face.F).toList())
+    }
+
+    @Test fun uMovesFrontToLeft() {
+        val c = NxnCube(3).apply("U")
+        assertEquals(listOf(5, 5, 5), c.face(NxnCube.Face.R).take(3)) // B comes to R
+        assertEquals(listOf(2, 2, 2), c.face(NxnCube.Face.L).take(3)) // F goes to L
+    }
+
+    @Test fun wideEqualsFacePlusSlice() {
+        val a = NxnCube(5).apply("Rw")
+        val b = NxnCube(5).apply("R 2R")
+        assertContentEquals(a.stickers, b.stickers)
+        assertContentEquals(NxnCube(3).apply("x").stickers, NxnCube(3).apply("R M' L'").stickers)
+    }
+
+    @Test fun tPermIsOrderTwo() {
+        val t = "R U R' U' R' F R2 U' R' U' R U R' F'"
+        val c = NxnCube(3).apply(t)
+        assertFalse(c.isSolved)
+        assertTrue(c.apply(t).isSolved)
+    }
+}
diff --git a/core/src/commonTest/kotlin/coffee/liz/rookery/ImportTest.kt b/core/src/commonTest/kotlin/coffee/liz/rookery/ImportTest.kt
new file mode 100644
index 0000000..ad7659c
--- /dev/null
+++ b/core/src/commonTest/kotlin/coffee/liz/rookery/ImportTest.kt
@@ -0,0 +1,76 @@
+package coffee.liz.rookery
+
+import coffee.liz.rookery.importer.CsTimerImport
+import coffee.liz.rookery.importer.Importer
+import coffee.liz.rookery.importer.LetterPairGymImport
+import coffee.liz.rookery.model.Event
+import coffee.liz.rookery.model.Penalty
+import coffee.liz.rookery.store.MemoryBlobStore
+import coffee.liz.rookery.store.MemoryLogStorage
+import coffee.liz.rookery.store.Repo
+import coffee.liz.rookery.store.Store
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class ImportTest {
+    private val csTimer = """
+        {"session1":[
+          [[0,114010],"Uw' L2 D L' R2 Dw D' R' F D Bw2 B2 Lw2 D2 Rw' Dw2 Lw' U' Dw' F2 B2 Rw D' Dw2 Lw2 R2 B2 Dw' Fw' Rw B2 Lw2 Uw' D F' Bw2 U Uw Bw2 F' R Dw2 Uw Rw' Dw D2 U Uw Lw' B2 F R' Uw2 B' R Lw2 B Lw L2 B'","",1794373390],
+          [[0,25058],"B' R' F2 U2 L2 F2 U2 B' L2 B2 U2 F' R2 U' F2 L D' L' B L2 F","",1794526179,["U'@0 L'@200","333"]],
+          [[2000,14039],"R U F","nice",1794526518],
+          [[-1,14245],"D2 F","",1794534484]],
+         "session2":[[[0,4000],"R U R' U'","",1794534500]],
+         "properties":{"sessionData":"{\"1\":{\"name\":1,\"opt\":{}},\"2\":{\"name\":\"pyra\",\"opt\":{\"scrType\":\"pyrso\"}}}","giiMacMap":"{\"null\":\"AA:BB:CC:DD:EE:FF\"}"}}
+    """.trimIndent()
+
+    @Test fun parsesCsTimer() {
+        val r = CsTimerImport.parse(csTimer)
+        assertEquals(5, r.solves.size)
+        val events = r.solves.map { it.event }
+        assertEquals(listOf(Event.E555, Event.E333, Event.E333, Event.E333, Event.PYRAM), events)
+        assertEquals(listOf(Penalty.NONE, Penalty.NONE, Penalty.PLUS2, Penalty.DNF), r.solves.take(4).map { it.penalty })
+        assertEquals("U'@0 L'@200", r.solves[1].moves)
+        assertEquals(1794373390_000, r.solves[0].at)
+        assertEquals(3, r.sessions.size)
+        assertTrue(r.sessions.any { it.name == "csTimer 1 (5x5)" })
+        assertEquals("AA:BB:CC:DD:EE:FF", r.devices.single().mac)
+    }
+
+    @Test fun importIsIdempotent() {
+        val repo = Repo(Store("t", MemoryLogStorage(), MemoryBlobStore()) { 1 })
+        Importer(repo).csTimer(csTimer)
+        Importer(repo).csTimer(csTimer)
+        assertEquals(5, repo.solves().size)
+        assertEquals(3, repo.sessions().size)
+        assertEquals(1, repo.devices().size)
+    }
+
+    private val gym = """
+        {"app":"letter-pair-gym","v":1,"at":"2026-11-13T03:28:27.903Z",
+         "settings":{"edgeScheme":"ABCDQRSTEFGHIJKLMNOPUVWX","eBuf":2},
+         "words":{"AB":"abacus","AD":"adelie","XW":""},
+         "notes":{"AD":"adelie penguin"},
+         "wordHist":[{"d":1794519658205,"from":"Peg","p":"PG","to":"Postgres"}],
+         "stats":{"AB":{"k":1,"l":[689],"m":5,"ms":61704.39,"n":11,"r":"gsmmsg","s":4}},
+         "memoHist":[{"d":1794505722395,"ms":154339,"ok":8,"p":10}],
+         "solves":[],
+         "images":{"AB":"images/AB - abacus.jpg","AD":"images/AD - missing.jpg"}}
+    """.trimIndent()
+
+    @Test fun importsLetterPairGym() {
+        val parsed = LetterPairGymImport.parse(gym)
+        assertEquals(mapOf("AB" to "abacus", "AD" to "adelie"), parsed.words)
+        assertEquals(listOf(689L), parsed.stats.getValue("AB").latenciesMs)
+
+        val repo = Repo(Store("t", MemoryLogStorage(), MemoryBlobStore()) { 1 })
+        val summary = Importer(repo).letterPairGym(gym) { path -> if (path.startsWith("images/AB")) byteArrayOf(1, 2, 3) else null }
+        val pairs = repo.letterPairs()
+        assertEquals("abacus", pairs.getValue("AB").primary)
+        assertEquals("adelie penguin", pairs.getValue("AD").note)
+        assertTrue(pairs.getValue("AB").image!!.endsWith(".jpg"))
+        assertEquals(1, summary.warnings.size)
+        assertEquals("Postgres", repo.wordHistory().single().to)
+        assertEquals(1, repo.memoSessions().size)
+    }
+}
diff --git a/core/src/commonTest/kotlin/coffee/liz/rookery/StatsTest.kt b/core/src/commonTest/kotlin/coffee/liz/rookery/StatsTest.kt
new file mode 100644
index 0000000..35fc1fc
--- /dev/null
+++ b/core/src/commonTest/kotlin/coffee/liz/rookery/StatsTest.kt
@@ -0,0 +1,54 @@
+package coffee.liz.rookery
+
+import coffee.liz.rookery.model.DNF
+import coffee.liz.rookery.model.formatTime
+import coffee.liz.rookery.stats.Averages
+import coffee.liz.rookery.stats.StatKind
+import coffee.liz.rookery.stats.StatSummary
+import coffee.liz.rookery.stats.newPersonalBests
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNull
+
+class StatsTest {
+    @Test fun ao5TrimsBestAndWorst() {
+        assertEquals(12000, Averages.average(listOf(10000, 11000, 12000, 13000, 20000)))
+        assertEquals(12000, Averages.average(listOf(10000, 11000, 12000, 13000, DNF)))
+        assertEquals(DNF, Averages.average(listOf(10000, 11000, 12000, DNF, DNF)))
+    }
+
+    @Test fun trimCounts() {
+        assertEquals(1, Averages.trim(5)); assertEquals(1, Averages.trim(12))
+        assertEquals(3, Averages.trim(50)); assertEquals(5, Averages.trim(100)); assertEquals(50, Averages.trim(1000))
+    }
+
+    @Test fun mo3AnyDnfIsDnf() {
+        assertEquals(DNF, Averages.mean(listOf(1, 2, DNF)))
+        assertEquals(2, Averages.mean(listOf(1, 2, 3)))
+    }
+
+    @Test fun slidingBestMatchesBruteForce() {
+        val rng = kotlin.random.Random(42)
+        val xs = List(300) { if (rng.nextInt(20) == 0) DNF else rng.nextLong(8000, 20000) }
+        for (n in listOf(5, 12, 100)) {
+            val brute = (0..xs.size - n).minOf { Averages.average(xs.subList(it, it + n)) }
+            assertEquals(brute, Averages.best(xs, n))
+        }
+        assertEquals((0..xs.size - 3).minOf { Averages.mean(xs.subList(it, it + 3)) }, Averages.best(xs, 3, mean = true))
+    }
+
+    @Test fun personalBestsFromLatestSolve() {
+        val before = listOf(15000L, 14000, 16000, 15500, 14500)
+        val after = before + 11000L
+        val pbs = newPersonalBests(StatSummary.of(before), StatSummary.of(after)).map { it.kind }
+        assertEquals(listOf(StatKind.SINGLE, StatKind.MO3, StatKind.AO5), pbs)
+        assertNull(newPersonalBests(StatSummary.of(after), StatSummary.of(after + 30000L)).firstOrNull { it.kind == StatKind.SINGLE })
+    }
+
+    @Test fun formatting() {
+        assertEquals("9.99", formatTime(9999))
+        assertEquals("10.00", formatTime(9999, round = true))
+        assertEquals("1:02.34", formatTime(62345))
+        assertEquals("DNF", formatTime(DNF))
+    }
+}
diff --git a/core/src/commonTest/kotlin/coffee/liz/rookery/StoreTest.kt b/core/src/commonTest/kotlin/coffee/liz/rookery/StoreTest.kt
new file mode 100644
index 0000000..e5fc945
--- /dev/null
+++ b/core/src/commonTest/kotlin/coffee/liz/rookery/StoreTest.kt
@@ -0,0 +1,65 @@
+package coffee.liz.rookery
+
+import coffee.liz.rookery.model.Event
+import coffee.liz.rookery.model.Penalty
+import coffee.liz.rookery.model.Solve
+import coffee.liz.rookery.store.Hlc
+import coffee.liz.rookery.store.HlcClock
+import coffee.liz.rookery.store.MemoryBlobStore
+import coffee.liz.rookery.store.MemoryLogStorage
+import coffee.liz.rookery.store.Repo
+import coffee.liz.rookery.store.Store
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class StoreTest {
+    @Test fun hlcOrdersAndRoundTrips() {
+        var now = 1000L
+        val c = HlcClock("a") { now }
+        val a = c.tick(); val b = c.tick()
+        assertTrue(b > a)
+        now = 500 // clock went backwards
+        assertTrue(c.tick() > b)
+        c.observe(Hlc(9999, 7, "z"))
+        assertTrue(c.tick() > Hlc(9999, 7, "z"))
+        assertEquals(a, Hlc.parse(a.toString()))
+        assertTrue(Hlc(5, 0, "a").toString() < Hlc(10, 0, "a").toString())
+    }
+
+    private fun solve(id: String, ms: Long) = Solve(id, "s", Event.E333, ms, Penalty.NONE, "R U", "", 1)
+
+    @Test fun twoDevicesConvergeRegardlessOfOrder() {
+        val shared = mutableListOf<String>()
+        var t = 0L
+        val a = Repo(Store("dev-a", MemoryLogStorage(shared), MemoryBlobStore()) { t })
+        val b = Repo(Store("dev-b", MemoryLogStorage(shared), MemoryBlobStore()) { t })
+
+        t = 10; a.addSolve(solve("x", 1000))
+        t = 11; b.addSolve(solve("y", 2000))
+        a.store.sync(); b.store.sync()
+        // concurrent edits to the same field: later stamp wins on both sides
+        t = 20; a.setPenalty("x", Penalty.PLUS2)
+        t = 21; b.setPenalty("x", Penalty.DNF)
+        t = 22; b.deleteSolve("y")
+        a.store.sync(); b.store.sync()
+
+        assertEquals(a.solves(), b.solves())
+        assertEquals(listOf("x"), a.solves().map { it.id })
+        assertEquals(Penalty.DNF, a.solves().single().penalty)
+    }
+
+    @Test fun letterPairWordsMergeAsSet() {
+        val shared = mutableListOf<String>()
+        var t = 0L
+        val a = Repo(Store("a", MemoryLogStorage(shared), MemoryBlobStore()) { t })
+        val b = Repo(Store("b", MemoryLogStorage(shared), MemoryBlobStore()) { t })
+        t = 1; a.setPrimaryWord("AB", "abacus", 1)
+        t = 2; b.setPrimaryWord("AB", "abba", 2)
+        a.store.sync(); b.store.sync()
+        val p = a.letterPairs().getValue("AB")
+        assertEquals("abba", p.primary)
+        assertEquals(setOf("abacus", "abba"), p.words)
+        assertEquals(2, a.wordHistory().size)
+    }
+}
diff --git a/core/src/commonTest/kotlin/coffee/liz/rookery/TimerTest.kt b/core/src/commonTest/kotlin/coffee/liz/rookery/TimerTest.kt
new file mode 100644
index 0000000..2ee2421
--- /dev/null
+++ b/core/src/commonTest/kotlin/coffee/liz/rookery/TimerTest.kt
@@ -0,0 +1,46 @@
+package coffee.liz.rookery
+
+import coffee.liz.rookery.model.Penalty
+import coffee.liz.rookery.timer.TimerMachine
+import coffee.liz.rookery.timer.TimerMachine.State
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertIs
+
+class TimerTest {
+    @Test fun inspectionFlowWithPlusTwo() {
+        val t = TimerMachine(inspection = true)
+        var result: Pair<Long, Penalty>? = null
+        t.onFinish = { ms, p -> result = ms to p }
+        t.press(0); t.tick(500); t.release(600)
+        assertIs<State.Inspecting>(t.state)
+        t.press(15_500); t.tick(15_700)
+        assertIs<State.Holding>(t.state)
+        t.tick(15_850)
+        assertIs<State.Ready>(t.state)
+        t.release(16_000)
+        assertEquals(State.Running(16_000, Penalty.PLUS2), t.state)
+        t.press(26_000)
+        assertEquals(10_000L to Penalty.PLUS2, result)
+        t.press(26_100) // still holding the stop key: nothing happens
+        assertIs<State.Stopped>(t.state)
+        t.release(26_200); t.press(27_000)
+        assertIs<State.Holding>(t.state)
+    }
+
+    @Test fun releasingEarlyDoesNotStart() {
+        val t = TimerMachine(inspection = false)
+        t.press(0); t.tick(100); t.release(150)
+        assertEquals(State.Idle, t.state)
+        t.press(200); t.tick(600); t.release(700)
+        assertIs<State.Running>(t.state)
+    }
+
+    @Test fun overInspectionIsDnf() {
+        val t = TimerMachine(inspection = true)
+        var p: Penalty? = null
+        t.onFinish = { _, pen -> p = pen }
+        t.press(0); t.release(10); t.tick(17_100)
+        assertEquals(Penalty.DNF, p)
+    }
+}
diff --git a/core/src/commonTest/kotlin/coffee/liz/rookery/TwistyPuzzleTest.kt b/core/src/commonTest/kotlin/coffee/liz/rookery/TwistyPuzzleTest.kt
new file mode 100644
index 0000000..09a1aae
--- /dev/null
+++ b/core/src/commonTest/kotlin/coffee/liz/rookery/TwistyPuzzleTest.kt
@@ -0,0 +1,72 @@
+package coffee.liz.rookery
+
+import coffee.liz.rookery.model.Puzzle
+import coffee.liz.rookery.puzzle.Notation
+import coffee.liz.rookery.puzzle.NxnCube
+import coffee.liz.rookery.puzzle.Puzzles
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNotNull
+import kotlin.test.assertTrue
+
+class TwistyPuzzleTest {
+    @Test fun stickerCounts() {
+        for (n in 2..7) assertEquals(6 * n * n, Puzzles.cube(n).stickers.size, "${n}x$n")
+        assertEquals(36, Puzzles.pyraminx().stickers.size)
+        assertEquals(30, Puzzles.skewb().stickers.size)
+    }
+
+    @Test fun stickersFaceOutwards() {
+        for (p in listOf(Puzzles.cube(3), Puzzles.pyraminx(), Puzzles.skewb())) {
+            for (s in p.stickers) assertTrue((s.normal dot s.centroid) > 0, "${p.name} sticker at ${s.centroid} faces inward")
+        }
+    }
+
+    @Test fun cubeMatchesNxnModelFaceByFace() {
+        val alg = "R U2 F' 2L Dw B2 3Rw' x U' M2 y' S"
+        for (n in listOf(3, 5, 7)) {
+            val generic = Puzzles.cube(n).solved().apply(alg)
+            val reference = NxnCube(n).apply(alg)
+            for (f in NxnCube.Face.entries) {
+                val mine = generic.colors.filterIndexed { i, _ -> generic.puzzle.stickerFace[i] == f.ordinal }.sorted()
+                assertEquals(reference.face(f).sorted(), mine, "${n}x$n face $f")
+            }
+            assertTrue(generic.apply(Notation.invert(alg)).isSolved)
+        }
+    }
+
+    @Test fun cubeMoveOrders() {
+        val c = Puzzles.cube(3).solved()
+        assertTrue(c.apply("R R R R").isSolved)
+        assertTrue(c.apply("R U R' U' ".repeat(6)).isSolved)
+        val t = "R U R' U' R' F R2 U' R' U' R U R' F'"
+        assertFalse(c.apply(t).isSolved)
+        assertTrue(c.apply("$t $t").isSolved)
+    }
+
+    @Test fun pyraminxMoves() {
+        val p = Puzzles.pyraminx().solved()
+        assertTrue(p.apply("U U U").isSolved)
+        assertTrue(p.apply("u u'").isSolved)
+        assertFalse(p.apply("U").isSolved)
+        // a tip turn only moves the 3 tip stickers
+        assertEquals(3, p.apply("u").colors.indices.count { p.apply("u").colors[it] != p.colors[it] })
+        val scr = "U' L' R B U' L B' U r' b"
+        assertTrue(p.apply(scr).apply("b' r U' B L' U B' R' L U").isSolved)
+    }
+
+    @Test fun skewbMoves() {
+        val s = Puzzles.skewb().solved()
+        assertTrue(s.apply("R R R").isSolved)
+        assertFalse(s.apply("R").isSolved)
+        // a skewb turn moves half the puzzle: 3 faces touch the turning corner fully-ish; count changes
+        val moved = s.apply("R").colors.indices.count { s.apply("R").colors[it] != s.colors[it] }
+        assertEquals(15, moved)
+        assertTrue(s.apply("R U' L B' R' U").apply("U' R B L' U R'").isSolved)
+    }
+
+    @Test fun modelsExistForCubesPyraAndSkewb() {
+        for (p in listOf(Puzzle.CUBE2, Puzzle.CUBE7, Puzzle.PYRAMINX, Puzzle.SKEWB)) assertNotNull(Puzzles.of(p))
+    }
+}
diff --git a/core/src/commonTest/kotlin/coffee/liz/rookery/bt/GanProtocolTest.kt b/core/src/commonTest/kotlin/coffee/liz/rookery/bt/GanProtocolTest.kt
new file mode 100644
index 0000000..5e45af3
--- /dev/null
+++ b/core/src/commonTest/kotlin/coffee/liz/rookery/bt/GanProtocolTest.kt
@@ -0,0 +1,264 @@
+package coffee.liz.rookery.bt
+
+import coffee.liz.rookery.bt.SmartCubeEvent.Battery
+import coffee.liz.rookery.bt.SmartCubeEvent.Facelets
+import coffee.liz.rookery.bt.SmartCubeEvent.Gyro
+import coffee.liz.rookery.bt.SmartCubeEvent.Hardware
+import coffee.liz.rookery.bt.SmartCubeEvent.Move
+import kotlinx.coroutines.test.runTest
+import kotlin.math.abs
+import kotlin.test.Test
+import kotlin.test.assertContentEquals
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+/** Records commands a driver sends back to the cube. */
+class RecordingRawConnection : GanRawConnection {
+    val sent = mutableListOf<ByteArray>()
+    var disconnects = 0
+    override suspend fun sendCommandMessage(message: ByteArray) { sent += message }
+    override suspend fun disconnect() { disconnects++ }
+}
+
+/** Cube state after F R (from gan-web-bluetooth's docs). */
+val F_R_STATE = CubeState(
+    cp = listOf(0, 5, 2, 1, 7, 4, 6, 3), co = listOf(1, 2, 0, 2, 1, 1, 0, 2),
+    ep = listOf(1, 9, 2, 3, 11, 8, 6, 7, 4, 5, 10, 0), eo = listOf(1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0),
+)
+const val F_R_FACELETS = "UUFUUFLLFUUURRRRRRFFRFFDFFDRRBDDBDDBLLDLLDLLDLBBUBBUBB"
+val SOLVED_STATE = CubeState(List(8) { it }, List(8) { 0 }, List(12) { it }, List(12) { 0 })
+
+/** Writes the first 7 corners / 11 edges of [s] at the given bit offsets, as the cube does. */
+fun GanBitWriter.state(s: CubeState, cpAt: Int, coAt: Int, epAt: Int, eoAt: Int): GanBitWriter {
+    for (i in 0 until 7) { put(cpAt + i * 3, 3, s.cp[i]); put(coAt + i * 2, 2, s.co[i]) }
+    for (i in 0 until 11) { put(epAt + i * 4, 4, s.ep[i]); put(eoAt + i, 1, s.eo[i]) }
+    return this
+}
+
+object Packets {
+    fun gen2Facelets(serial: Int, s: CubeState) = GanBitWriter(20).put(0, 4, 0x4).put(4, 8, serial).state(s, 12, 33, 47, 91).bytes
+
+    /** [moves] newest first: (face 0..5 URFDLB, direction 0/1, elapsed ms since previous move). */
+    fun gen2Moves(serial: Int, moves: List<Triple<Int, Int, Int>>): ByteArray {
+        val w = GanBitWriter(20).put(0, 4, 0x2).put(4, 8, serial)
+        moves.forEachIndexed { i, (face, dir, elapsed) -> w.put(12 + 5 * i, 4, face).put(16 + 5 * i, 1, dir).put(47 + 16 * i, 16, elapsed) }
+        return w.bytes
+    }
+
+    // Live-move face codes for Gen3/Gen4, indexed by face URFDLB.
+    val LIVE = listOf(2, 32, 8, 1, 16, 4)
+    val HISTORY = listOf(1, 5, 3, 0, 4, 2)
+
+    fun gen3Facelets(serial: Int, s: CubeState) =
+        GanBitWriter(20).put(0, 8, 0x55).put(8, 8, 0x02).put(16, 8, 0x10).put(24, 16, serial, true).state(s, 40, 61, 77, 121).bytes
+
+    fun gen3Move(serial: Int, face: Int, dir: Int, cubeTs: Long) =
+        GanBitWriter(16).put(0, 8, 0x55).put(8, 8, 0x01).put(16, 8, 0x08).put(24, 32, cubeTs, true)
+            .put(56, 16, serial, true).put(72, 2, dir).put(74, 6, LIVE[face]).bytes
+
+    fun gen4Facelets(serial: Int, s: CubeState) =
+        GanBitWriter(20).put(0, 8, 0xED).put(8, 8, 0x10).put(16, 16, serial, true).state(s, 32, 53, 69, 113).bytes
+
+    fun gen4Move(serial: Int, face: Int, dir: Int, cubeTs: Long) =
+        GanBitWriter(20).put(0, 8, 0x01).put(8, 8, 0x08).put(16, 32, cubeTs, true)
+            .put(48, 16, serial, true).put(64, 2, dir).put(66, 6, LIVE[face]).bytes
+
+    /** Gen4 move history: [moves] are (face, dir) for serials startSerial, startSerial-1, ... */
+    fun gen4History(startSerial: Int, moves: List<Pair<Int, Int>>): ByteArray {
+        val w = GanBitWriter(20).put(0, 8, 0xD1).put(8, 8, moves.size / 2 + 1).put(16, 8, startSerial)
+        moves.forEachIndexed { i, (face, dir) -> w.put(24 + 4 * i, 3, HISTORY[face]).put(27 + 4 * i, 1, dir) }
+        return w.bytes
+    }
+}
+
+class GanProtocolTest {
+    private var now = 1_000L
+    private val clock = { now }
+
+    @Test fun bitReaderRoundTripsAllWidths() {
+        val w = GanBitWriter(12).put(3, 5, 0b10110).put(8, 16, 0xBEEF).put(27, 16, 0x1234, true).put(43, 32, 0xDEADBEEFL, true)
+        val r = GanBitReader(w.bytes)
+        assertEquals(0b10110, r.bits(3, 5))
+        assertEquals(0xBEEF, r.bits(8, 16))
+        assertEquals(0x1234, r.bits(27, 16, true))
+        assertEquals(0xDEADBEEFL, r.u32(43, true))
+        assertEquals(0, r.bits(200, 8)) // past the end reads as zero
+    }
+
+    @Test fun kociembaFacelets() {
+        assertEquals(GanFacelets.SOLVED, GanFacelets.toKociemba(SOLVED_STATE))
+        assertEquals(F_R_FACELETS, GanFacelets.toKociemba(F_R_STATE))
+        val completed = GanFacelets.complete(F_R_STATE.cp.take(7), F_R_STATE.co.take(7), F_R_STATE.ep.take(11), F_R_STATE.eo.take(11))
+        assertEquals(F_R_STATE, completed)
+    }
+
+    @Test fun gen2Commands() {
+        val d = GanGen2ProtocolDriver(clock)
+        assertEquals(20, d.createCommandMessage(GanCommand.REQUEST_FACELETS).size)
+        assertEquals(0x04, d.createCommandMessage(GanCommand.REQUEST_FACELETS)[0].toInt())
+        assertEquals(0x05, d.createCommandMessage(GanCommand.REQUEST_HARDWARE)[0].toInt())
+        assertEquals(0x09, d.createCommandMessage(GanCommand.REQUEST_BATTERY)[0].toInt())
+        assertContentEquals(
+            byteArrayOf(0x0A, 0x05, 0x39, 0x77, 0, 0, 0x01, 0x23, 0x45, 0x67, 0x89.toByte(), 0xAB.toByte(), 0, 0, 0, 0, 0, 0, 0, 0),
+            d.createCommandMessage(GanCommand.REQUEST_RESET),
+        )
+    }
+
+    @Test fun gen2FaceletsMovesBatteryHardwareGyro() = runTest {
+        val d = GanGen2ProtocolDriver(clock)
+        val c = RecordingRawConnection()
+        // Moves before the first facelets event are ignored.
+        assertEquals(emptyList(), d.handleStateEvent(c, Packets.gen2Moves(5, listOf(Triple(1, 0, 100)))))
+
+        val f = d.handleStateEvent(c, Packets.gen2Facelets(10, F_R_STATE)).single() as Facelets
+        assertEquals(F_R_FACELETS, f.facelets)
+        assertEquals(10, f.serial)
+        assertEquals(F_R_STATE, f.state)
+
+        now = 2_000
+        // Serial 11: one new move R (face 1, CW), 120 ms after the previous.
+        val m1 = d.handleStateEvent(c, Packets.gen2Moves(11, listOf(Triple(1, 0, 120)))).single() as Move
+        assertEquals(Move("R", 120, 2_000, 11, recovered = false), m1)
+
+        // Serial 13: two moves; the older (U', serial 12) was missed live and comes with the newer (F, serial 13).
+        now = 2_500
+        val ms = d.handleStateEvent(c, Packets.gen2Moves(13, listOf(Triple(2, 0, 200), Triple(0, 1, 150))))
+        assertEquals(listOf(Move("U'", 270, 2_500, 12, true), Move("F", 470, 2_500, 13, false)), ms)
+
+        val battery = GanBitWriter(20).put(0, 4, 0x9).put(8, 8, 87).bytes
+        assertEquals(Battery(87), d.handleStateEvent(c, battery).single())
+        assertEquals(Battery(100), d.handleStateEvent(c, GanBitWriter(20).put(0, 4, 0x9).put(8, 8, 140).bytes).single())
+
+        val hw = GanBitWriter(20).put(0, 4, 0x5).put(8, 8, 1).put(16, 8, 2).put(24, 8, 3).put(32, 8, 4).put(104, 1, 1)
+        "GAN12ui!".forEachIndexed { i, ch -> hw.put(40 + 8 * i, 8, ch.code) }
+        assertEquals(Hardware("GAN12ui!", "1.2", "3.4", null, true), d.handleStateEvent(c, hw.bytes).single())
+
+        // Gyro: w = +1, x = -0.5 (sign bit + magnitude), velocity x = -3.
+        val g = GanBitWriter(20).put(0, 4, 0x1).put(4, 16, 0x7FFF).put(20, 16, 0x8000 or 0x3FFF).put(68, 4, 0b1011)
+        val gyro = d.handleStateEvent(c, g.bytes).single() as Gyro
+        assertEquals(1.0, gyro.quaternion.w)
+        assertTrue(abs(gyro.quaternion.x + 0.5) < 1e-3)
+        assertEquals(-3, gyro.velocity!!.x)
+
+        assertEquals(emptyList(), d.handleStateEvent(c, GanBitWriter(20).put(0, 4, 0xD).bytes))
+        assertEquals(1, c.disconnects)
+    }
+
+    @Test fun gen3Commands() {
+        val d = GanGen3ProtocolDriver(clock)
+        assertContentEquals(byteArrayOf(0x68, 0x01) + ByteArray(14), d.createCommandMessage(GanCommand.REQUEST_FACELETS))
+        assertContentEquals(byteArrayOf(0x68, 0x04) + ByteArray(14), d.createCommandMessage(GanCommand.REQUEST_HARDWARE))
+        assertContentEquals(byteArrayOf(0x68, 0x07) + ByteArray(14), d.createCommandMessage(GanCommand.REQUEST_BATTERY))
+        assertEquals(0x05, d.createCommandMessage(GanCommand.REQUEST_RESET)[2].toInt())
+    }
+
+    @Test fun gen3FaceletsMovesBatteryHardware() = runTest {
+        val d = GanGen3ProtocolDriver(clock)
+        val c = RecordingRawConnection()
+        assertEquals(emptyList(), d.handleStateEvent(c, Packets.gen3Move(1, 0, 0, 10)))
+        assertEquals(Facelets(GanFacelets.SOLVED, 7, SOLVED_STATE), d.handleStateEvent(c, Packets.gen3Facelets(7, SOLVED_STATE)).single())
+        assertEquals(Move("L'", 123_456, 1_000, 8), d.handleStateEvent(c, Packets.gen3Move(8, 4, 1, 123_456)).single())
+        assertEquals(Move("B", 0xFFFFFFF0L, 1_000, 9), d.handleStateEvent(c, Packets.gen3Move(9, 5, 0, 0xFFFFFFF0L)).single())
+        // Wrong magic is ignored.
+        assertEquals(emptyList(), d.handleStateEvent(c, Packets.gen3Move(10, 0, 0, 1).also { it[0] = 0x54 }))
+
+        val battery = GanBitWriter(16).put(0, 8, 0x55).put(8, 8, 0x10).put(16, 8, 1).put(24, 8, 64).bytes
+        assertEquals(Battery(64), d.handleStateEvent(c, battery).single())
+
+        val hw = GanBitWriter(16).put(0, 8, 0x55).put(8, 8, 0x07).put(16, 8, 9).put(72, 4, 2).put(76, 4, 5).put(80, 4, 1).put(84, 4, 0)
+        "GANic".forEachIndexed { i, ch -> hw.put(32 + 8 * i, 8, ch.code) }
+        assertEquals(Hardware("GANic", "1.0", "2.5", null, false), d.handleStateEvent(c, hw.bytes).single())
+    }
+
+    @Test fun gen4Commands() {
+        val d = GanGen4ProtocolDriver(clock)
+        assertContentEquals(byteArrayOf(0xDD.toByte(), 0x04, 0x00, 0xED.toByte(), 0, 0) + ByteArray(14), d.createCommandMessage(GanCommand.REQUEST_FACELETS))
+        assertContentEquals(byteArrayOf(0xDD.toByte(), 0x04, 0x00, 0xEF.toByte(), 0, 0) + ByteArray(14), d.createCommandMessage(GanCommand.REQUEST_BATTERY))
+        assertContentEquals(byteArrayOf(0xDF.toByte(), 0x03) + ByteArray(18), d.createCommandMessage(GanCommand.REQUEST_HARDWARE))
+        assertEquals(0xD2.toByte(), d.createCommandMessage(GanCommand.REQUEST_RESET)[0])
+    }
+
+    @Test fun gen4MovesRecoverMissedMovesFromHistory() = runTest {
+        val d = GanGen4ProtocolDriver(clock)
+        val c = RecordingRawConnection()
+        assertEquals(F_R_FACELETS, (d.handleStateEvent(c, Packets.gen4Facelets(10, F_R_STATE)).single() as Facelets).facelets)
+        assertEquals(listOf(Move("D", 5000, 1_000, 11)), d.handleStateEvent(c, Packets.gen4Move(11, 3, 0, 5000)))
+
+        // Serial 14 arrives but 12 and 13 were lost: it is held back and history is requested.
+        assertEquals(emptyList(), d.handleStateEvent(c, Packets.gen4Move(14, 1, 1, 5600)))
+        assertContentEquals(byteArrayOf(0xD1.toByte(), 0x04, 13, 0, 4, 0) + ByteArray(14), c.sent.single())
+
+        // History: serials 13 (F'), 12 (U), 11 (D), 10 (whatever) newest first.
+        now = 1_050
+        val recovered = d.handleStateEvent(c, Packets.gen4History(13, listOf(2 to 1, 0 to 0, 3 to 0, 5 to 0)))
+        assertEquals(
+            listOf(Move("U", null, 1_050, 12, true), Move("F'", null, 1_050, 13, true), Move("R'", 5600, 1_000, 14)),
+            recovered,
+        )
+    }
+
+    @Test fun gen4FaceletsTriggerHistoryWhenIdle() = runTest {
+        val d = GanGen4ProtocolDriver(clock)
+        val c = RecordingRawConnection()
+        d.handleStateEvent(c, Packets.gen4Facelets(20, SOLVED_STATE))
+        d.handleStateEvent(c, Packets.gen4Move(21, 0, 0, 100))
+        // Periodic facelets says serial 23 more than 500 ms after the last move: 22 and 23 were missed.
+        now += 600
+        d.handleStateEvent(c, Packets.gen4Facelets(23, SOLVED_STATE))
+        assertContentEquals(byteArrayOf(0xD1.toByte(), 0x04, 23, 0, 4, 0) + ByteArray(14), c.sent.single())
+        val got = d.handleStateEvent(c, Packets.gen4History(23, listOf(1 to 0, 2 to 0, 0 to 0, 0 to 0)))
+        assertEquals(listOf("F", "R"), got.map { (it as Move).move })
+        assertEquals(listOf(22, 23), got.map { (it as Move).serial })
+    }
+
+    @Test fun gen4BatteryHardwareGyro() = runTest {
+        val d = GanGen4ProtocolDriver(clock)
+        val c = RecordingRawConnection()
+        // Battery level sits right after the payload: byte 1 + dataLength.
+        val battery = GanBitWriter(20).put(0, 8, 0xEF).put(8, 8, 3).put(32, 8, 55).bytes
+        assertEquals(Battery(55), d.handleStateEvent(c, battery).single())
+
+        d.createCommandMessage(GanCommand.REQUEST_HARDWARE)
+        val date = GanBitWriter(20).put(0, 8, 0xFA).put(8, 8, 5).put(24, 16, 2023, true).put(40, 8, 7).put(48, 8, 9).bytes
+        val nameW = GanBitWriter(20).put(0, 8, 0xFC).put(8, 8, 9)
+        "GAN12uiM".forEachIndexed { i, ch -> nameW.put(24 + 8 * i, 8, ch.code) }
+        val sw = GanBitWriter(20).put(0, 8, 0xFD).put(8, 8, 2).put(24, 4, 1).put(28, 4, 6).bytes
+        val hw = GanBitWriter(20).put(0, 8, 0xFE).put(8, 8, 2).put(24, 4, 1).put(28, 4, 1).bytes
+        assertEquals(emptyList(), d.handleStateEvent(c, date))
+        assertEquals(emptyList(), d.handleStateEvent(c, nameW.bytes))
+        assertEquals(emptyList(), d.handleStateEvent(c, sw))
+        assertEquals(Hardware("GAN12uiM", "1.1", "1.6", "2023-07-09", true), d.handleStateEvent(c, hw).single())
+
+        val g = GanBitWriter(20).put(0, 8, 0xEC).put(8, 8, 0x0A).put(16, 16, 0x7FFF).put(48, 16, 0x8000 or 0x7FFF).put(88, 4, 0b0010).bytes
+        val gyro = d.handleStateEvent(c, g).single() as Gyro
+        assertEquals(Quaternion(0.0, -1.0, 0.0, 1.0), gyro.quaternion)
+        assertEquals(AngularVelocity(0, 0, 2), gyro.velocity)
+    }
+
+    @Test fun timestampLinearFit() {
+        // Cube clock runs 10% slow relative to the host.
+        val fit = GanTimestampFit.linearFit(listOf(TimedMove("R", 1000, 0), TimedMove("U", 1110, 100), TimedMove("R'", 1220, 200)))
+        assertEquals(listOf(0L, 110L, 220L), fit.map { it.cubeTimestampMs })
+        assertEquals(-9.091, GanTimestampFit.skewPercent(listOf(TimedMove("R", 1000, 0), TimedMove("U", 1110, 100), TimedMove("R'", 1220, 200))))
+
+        // A recovered move without timestamps is interpolated from its neighbours (next - 50 ms).
+        val gap = GanTimestampFit.linearFit(listOf(TimedMove("R", 1000, 0), TimedMove("U", null, null), TimedMove("R'", 1220, 200)))
+        assertEquals(listOf(0L, 165L, 220L), gap.map { it.cubeTimestampMs })
+        val lastMissing = GanTimestampFit.linearFit(listOf(TimedMove("R", 1000, 0), TimedMove("U", 1100, 100), TimedMove("R'", null, null)))
+        assertEquals(listOf(0L, 100L, 150L), lastMissing.map { it.cubeTimestampMs })
+        assertEquals(emptyList(), GanTimestampFit.linearFit(emptyList()))
+    }
+
+    @Test fun macAndScanHelpers() {
+        assertContentEquals(byteArrayOf(0x78, 0x56, 0x34, 0x12, 0xF0.toByte(), 0x6F), GanDefinitions.saltFromMac("6F:F0:12:34:56:78"))
+        assertContentEquals(GanDefinitions.saltFromMac("6f-f0-12-34-56-78"), GanDefinitions.saltFromMac("6F:F0:12:34:56:78"))
+        // Manufacturer data (company 0x1201): 3 bytes of something, then the MAC reversed.
+        val mfr = mapOf(0x1201 to byteArrayOf(1, 2, 3, 0x78, 0x56, 0x34, 0x12, 0xF0.toByte(), 0x6F, 9, 9))
+        assertEquals("6F:F0:12:34:56:78", GanDefinitions.macFromManufacturerData(mfr))
+        assertTrue(GanCubeConnector.isGanCube(BleAdvertisement("6F:F0:12:34:56:78", null, -60, mfr)))
+        assertTrue(GanCubeConnector.isGanCube(BleAdvertisement("00:11:22:33:44:55", "GAN12uiM_1A2B", -60)))
+        assertTrue(GanCubeConnector.isGanCube(BleAdvertisement("00:11:22:33:44:55", null, -60, serviceUuids = listOf(GanDefinitions.GEN3_SERVICE))))
+        assertTrue(!GanCubeConnector.isGanCube(BleAdvertisement("00:11:22:33:44:55", "Headphones", -60, mfr)))
+        assertEquals(GanGeneration.GEN4, GanGeneration.fromServiceUuids(listOf("0000180a-0000-1000-8000-00805f9b34fb", GanDefinitions.GEN4_SERVICE.uppercase())))
+    }
+}
diff --git a/core/src/jvmMain/kotlin/coffee/liz/rookery/Platform.jvm.kt b/core/src/jvmMain/kotlin/coffee/liz/rookery/Platform.jvm.kt
new file mode 100644
index 0000000..bbccb57
--- /dev/null
+++ b/core/src/jvmMain/kotlin/coffee/liz/rookery/Platform.jvm.kt
@@ -0,0 +1,6 @@
+package coffee.liz.rookery
+
+actual fun epochMillis(): Long = System.currentTimeMillis()
+actual fun monoMillis(): Long = System.nanoTime() / 1_000_000
+actual fun randomId(): String = java.util.UUID.randomUUID().toString().replace("-", "").take(16)
+actual fun <T> locked(lock: Any, block: () -> T): T = synchronized(lock, block)
diff --git a/core/src/jvmMain/kotlin/coffee/liz/rookery/audio/ChimePlayer.kt b/core/src/jvmMain/kotlin/coffee/liz/rookery/audio/ChimePlayer.kt
new file mode 100644
index 0000000..3b70b67
--- /dev/null
+++ b/core/src/jvmMain/kotlin/coffee/liz/rookery/audio/ChimePlayer.kt
@@ -0,0 +1,21 @@
+package coffee.liz.rookery.audio
+
+import javax.sound.sampled.AudioFormat
+import javax.sound.sampled.AudioSystem
+
+/** Plays [Chime] PCM on a daemon thread. Silently does nothing if there's no audio device. */
+object ChimePlayer {
+    fun play(notes: List<Chime.Note>) {
+        val pcm = Chime.render(notes)
+        Thread {
+            runCatching {
+                val format = AudioFormat(Chime.SAMPLE_RATE.toFloat(), 16, 1, true, false)
+                val bytes = ByteArray(pcm.size * 2)
+                for (i in pcm.indices) { bytes[2 * i] = pcm[i].toByte(); bytes[2 * i + 1] = (pcm[i].toInt() shr 8).toByte() }
+                AudioSystem.getSourceDataLine(format).use { line ->
+                    line.open(format); line.start(); line.write(bytes, 0, bytes.size); line.drain()
+                }
+            }
+        }.apply { isDaemon = true; name = "chime" }.start()
+    }
+}
diff --git a/core/src/jvmMain/kotlin/coffee/liz/rookery/bt/BlueZTransport.kt b/core/src/jvmMain/kotlin/coffee/liz/rookery/bt/BlueZTransport.kt
new file mode 100644
index 0000000..db2ae70
--- /dev/null
+++ b/core/src/jvmMain/kotlin/coffee/liz/rookery/bt/BlueZTransport.kt
@@ -0,0 +1,287 @@
+@file:Suppress("FunctionName")
+
+package coffee.liz.rookery.bt
+
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.NonCancellable
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.callbackFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.receiveAsFlow
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeoutOrNull
+import kotlinx.coroutines.channels.awaitClose
+import org.freedesktop.dbus.DBusPath
+import org.freedesktop.dbus.annotations.DBusInterfaceName
+import org.freedesktop.dbus.connections.impl.DBusConnection
+import org.freedesktop.dbus.connections.impl.DBusConnectionBuilder
+import org.freedesktop.dbus.interfaces.DBusInterface
+import org.freedesktop.dbus.interfaces.ObjectManager
+import org.freedesktop.dbus.interfaces.Properties
+import org.freedesktop.dbus.types.Variant
+import java.util.concurrent.CopyOnWriteArrayList
+
+@DBusInterfaceName("org.bluez.Adapter1")
+@JvmSuppressWildcards
+internal interface BluezAdapter1 : DBusInterface {
+    fun StartDiscovery()
+    fun StopDiscovery()
+    fun SetDiscoveryFilter(filter: Map<String, Variant<*>>)
+}
+
+@DBusInterfaceName("org.bluez.Device1")
+internal interface BluezDevice1 : DBusInterface {
+    fun Connect()
+    fun Disconnect()
+}
+
+@DBusInterfaceName("org.bluez.GattCharacteristic1")
+@JvmSuppressWildcards
+internal interface BluezGattCharacteristic1 : DBusInterface {
+    fun ReadValue(options: Map<String, Variant<*>>): ByteArray
+    fun WriteValue(value: ByteArray, options: Map<String, Variant<*>>)
+    fun StartNotify()
+    fun StopNotify()
+}
+
+/**
+ * [BleTransport] over BlueZ's D-Bus API (Linux). Only discovers, connects and disconnects:
+ * never pairs, trusts or changes adapter settings. Close it to release the D-Bus connection.
+ */
+class BlueZTransport(private val adapterName: String? = null) : BleTransport, AutoCloseable {
+    private val bus: DBusConnection by lazy {
+        DBusConnectionBuilder.forSystemBus().withShared(false).build().also { c ->
+            c.addSigHandler(Properties.PropertiesChanged::class.java) { s ->
+                // dbus-java can't match on a well-known sender name, so filter by BlueZ's object paths instead.
+                if (s.path.startsWith(BLUEZ_ROOT)) listeners.forEach { it(s.path, s.interfaceName, s.propertiesChanged) }
+            }
+            c.addSigHandler(ObjectManager.InterfacesAdded::class.java) { s ->
+                val path = s.signalSource.path
+                if (path.startsWith(BLUEZ_ROOT)) s.interfaces.forEach { (iface, props) -> listeners.forEach { it(path, iface, props) } }
+            }
+        }
+    }
+
+    /** (objectPath, interface, changedProperties) */
+    private val listeners = CopyOnWriteArrayList<(String, String, Map<String, Variant<*>>) -> Unit>()
+
+    private fun managedObjects(): Map<String, Map<String, Map<String, Variant<*>>>> =
+        bus.getRemoteObject(BLUEZ, "/", ObjectManager::class.java).GetManagedObjects().mapKeys { it.key.path }
+
+    private fun adapterPath(objects: Map<String, Map<String, Map<String, Variant<*>>>> = managedObjects()): String {
+        val adapters = objects.filterValues { ADAPTER in it }.keys.sorted()
+        if (adapterName != null) return adapters.firstOrNull { it.endsWith("/$adapterName") } ?: error("No Bluetooth adapter $adapterName")
+        return adapters.firstOrNull { objects[it]!![ADAPTER]!!["Powered"]?.value == true } ?: adapters.firstOrNull()
+            ?: error("No Bluetooth adapter found (is bluetoothd running?)")
+    }
+
+    private fun adapter(path: String) = bus.getRemoteObject(BLUEZ, path, BluezAdapter1::class.java)
+
+    private fun devicePath(adapter: String, address: String) = "$adapter/dev_" + address.uppercase().replace(':', '_')
+
+    override fun scan(): Flow<BleAdvertisement> = callbackFlow {
+        val objects = managedObjects()
+        val adapterPath = adapterPath(objects)
+        val devices = HashMap<String, MutableMap<String, Any?>>()
+        fun update(path: String, props: Map<String, Variant<*>>, emitIfNoRssi: Boolean) {
+            if (!path.startsWith("$adapterPath/dev_") || path.count { it == '/' } != adapterPath.count { it == '/' } + 1) return
+            val merged = synchronized(devices) {
+                devices.getOrPut(path) { HashMap() }.also { m -> props.forEach { (k, v) -> m[k] = v.value } }.toMap()
+            }
+            if (!emitIfNoRssi && merged["RSSI"] == null) return
+            toAdvertisement(merged)?.let { trySend(it) }
+        }
+        val listener: (String, String, Map<String, Variant<*>>) -> Unit = { path, iface, props -> if (iface == DEVICE) update(path, props, true) }
+        listeners += listener
+        // Devices BlueZ already knows about are only reported if they carry a recent RSSI.
+        objects.forEach { (path, ifaces) -> ifaces[DEVICE]?.let { update(path, it, false) } }
+        val adapter = adapter(adapterPath)
+        runCatching { adapter.SetDiscoveryFilter(mapOf("Transport" to Variant("le"), "DuplicateData" to Variant(true))) }
+        try {
+            adapter.StartDiscovery()
+        } catch (e: Exception) {
+            // Another client may already be discovering on this adapter; that still yields results.
+            if (e.message?.contains("InProgress") != true) {
+                listeners -= listener
+                throw e
+            }
+        }
+        awaitClose {
+            listeners -= listener
+            runCatching { adapter.StopDiscovery() }
+        }
+    }.flowOn(Dispatchers.IO)
+
+    override suspend fun connect(address: String): BleConnection = withContext(Dispatchers.IO) {
+        val objects = managedObjects()
+        val adapterPath = adapterPath(objects)
+        val path = devicePath(adapterPath, address)
+        if (path !in objects) {
+            // BlueZ only knows devices it has seen: discover until this one shows up.
+            withTimeoutOrNull(20_000) { scan().first { it.address.equals(address, ignoreCase = true) } }
+                ?: error("Device $address not found; is it awake and in range?")
+        }
+        val conn = BlueZConnection(path, address)
+        try {
+            conn.open()
+        } catch (e: Throwable) {
+            conn.close()
+            throw e
+        }
+        conn
+    }
+
+    override fun close() {
+        runCatching { bus.close() }
+    }
+
+    private fun props(path: String, iface: String): Map<String, Any?> =
+        bus.getRemoteObject(BLUEZ, path, Properties::class.java).GetAll(iface).mapValues { it.value.value }
+
+    private inner class BlueZConnection(private val path: String, override val address: String) : BleConnection {
+        private val device = bus.getRemoteObject(BLUEZ, path, BluezDevice1::class.java)
+        private val gone = CompletableDeferred<Unit>()
+        private val notifying = CopyOnWriteArrayList<String>()
+        private val channels = CopyOnWriteArrayList<Channel<ByteArray>>()
+        private val ownListeners = CopyOnWriteArrayList<(String, String, Map<String, Variant<*>>) -> Unit>()
+        private var chars: Map<Pair<String, String>, String> = emptyMap()
+        override var name: String? = null
+            private set
+
+        private fun listen(l: (String, String, Map<String, Variant<*>>) -> Unit) {
+            ownListeners += l
+            listeners += l
+        }
+
+        suspend fun open() {
+            listen { p, iface, changed ->
+                if (p == path && iface == DEVICE && changed["Connected"]?.value == false) markGone()
+            }
+            var last: Exception? = null
+            for (attempt in 1..3) {
+                try {
+                    device.Connect()
+                    last = null
+                    break
+                } catch (e: Exception) {
+                    // "le-connection-abort-by-local" and friends are common and usually transient.
+                    last = e
+                    delay(500)
+                }
+            }
+            last?.let { throw IllegalStateException("Connect to $address failed: ${it.message}", it) }
+            val resolved = withTimeoutOrNull(15_000) {
+                while (props(path, DEVICE)["ServicesResolved"] != true) delay(100)
+                true
+            }
+            check(resolved == true) { "GATT services of $address were not resolved in time" }
+            val p = props(path, DEVICE)
+            name = p["Name"] as? String
+        }
+
+        override suspend fun discoverServices(): List<BleService> = withContext(Dispatchers.IO) {
+            val objects = managedObjects().filterKeys { it.startsWith("$path/") }
+            val services = objects.mapNotNull { (p, ifaces) -> ifaces[GATT_SERVICE]?.let { p to (it["UUID"]!!.value as String).lowercase() } }.toMap()
+            val found = HashMap<Pair<String, String>, String>()
+            val byService = HashMap<String, MutableList<BleCharacteristic>>()
+            objects.forEach { (p, ifaces) ->
+                val c = ifaces[GATT_CHAR] ?: return@forEach
+                val servicePath = (c["Service"]?.value as? DBusPath)?.path ?: p.substringBeforeLast('/')
+                val serviceUuid = services[servicePath] ?: return@forEach
+                val uuid = (c["UUID"]!!.value as String).lowercase()
+                found[serviceUuid to uuid] = p
+                byService.getOrPut(servicePath) { mutableListOf() } += BleCharacteristic(uuid, stringList(c["Flags"]?.value).toSet())
+            }
+            chars = found
+            services.map { (p, uuid) -> BleService(uuid, byService[p].orEmpty()) }
+        }
+
+        private fun charPath(service: String, characteristic: String): String =
+            chars[service.lowercase() to characteristic.lowercase()] ?: error("Characteristic $characteristic of service $service not found")
+
+        private fun char(service: String, characteristic: String) =
+            bus.getRemoteObject(BLUEZ, charPath(service, characteristic), BluezGattCharacteristic1::class.java)
+
+        override suspend fun read(service: String, characteristic: String): ByteArray = withContext(Dispatchers.IO) {
+            char(service, characteristic).ReadValue(emptyMap())
+        }
+
+        override suspend fun write(service: String, characteristic: String, value: ByteArray) = withContext(Dispatchers.IO) {
+            char(service, characteristic).WriteValue(value, emptyMap())
+        }
+
+        override suspend fun subscribe(service: String, characteristic: String): Flow<ByteArray> = withContext(Dispatchers.IO) {
+            val cp = charPath(service, characteristic)
+            val ch = Channel<ByteArray>(Channel.UNLIMITED)
+            channels += ch
+            listen { p, iface, changed ->
+                if (p == cp && iface == GATT_CHAR) changed["Value"]?.let { v -> toBytes(v.value)?.let { ch.trySend(it) } }
+            }
+            bus.getRemoteObject(BLUEZ, cp, BluezGattCharacteristic1::class.java).StartNotify()
+            notifying += cp
+            ch.receiveAsFlow()
+        }
+
+        override val disconnected: Flow<Unit> = flow { gone.await(); emit(Unit) }
+
+        private fun markGone() {
+            channels.forEach { it.close() }
+            gone.complete(Unit)
+        }
+
+        fun close() {
+            ownListeners.forEach { listeners -= it }
+            markGone()
+        }
+
+        override suspend fun disconnect() = withContext(NonCancellable + Dispatchers.IO) {
+            notifying.forEach { cp -> runCatching { bus.getRemoteObject(BLUEZ, cp, BluezGattCharacteristic1::class.java).StopNotify() } }
+            notifying.clear()
+            runCatching { device.Disconnect() }
+            close()
+        }
+    }
+
+    private companion object {
+        const val BLUEZ = "org.bluez"
+        const val BLUEZ_ROOT = "/org/bluez/"
+        const val ADAPTER = "org.bluez.Adapter1"
+        const val DEVICE = "org.bluez.Device1"
+        const val GATT_SERVICE = "org.bluez.GattService1"
+        const val GATT_CHAR = "org.bluez.GattCharacteristic1"
+
+        fun toBytes(v: Any?): ByteArray? = when (v) {
+            is ByteArray -> v
+            is List<*> -> ByteArray(v.size) { (v[it] as Number).toByte() }
+            is Array<*> -> ByteArray(v.size) { (v[it] as Number).toByte() }
+            else -> null
+        }
+
+        fun stringList(v: Any?): List<String> = when (v) {
+            is List<*> -> v.map { it.toString() }
+            is Array<*> -> v.map { it.toString() }
+            else -> emptyList()
+        }
+
+        fun toAdvertisement(p: Map<String, Any?>): BleAdvertisement? {
+            val address = p["Address"] as? String ?: return null
+            val mfr = (p["ManufacturerData"] as? Map<*, *>)?.mapNotNull { (k, v) ->
+                val id = (k as? Number)?.toInt() ?: return@mapNotNull null
+                val bytes = toBytes((v as? Variant<*>)?.value ?: v) ?: return@mapNotNull null
+                id to bytes
+            }?.toMap().orEmpty()
+            return BleAdvertisement(
+                address = address,
+                name = p["Name"] as? String,
+                rssi = (p["RSSI"] as? Number)?.toInt(),
+                manufacturerData = mfr,
+                serviceUuids = stringList(p["UUIDs"]).map { it.lowercase() },
+            )
+        }
+    }
+}
diff --git a/core/src/jvmMain/kotlin/coffee/liz/rookery/bt/JvmAes128.kt b/core/src/jvmMain/kotlin/coffee/liz/rookery/bt/JvmAes128.kt
new file mode 100644
index 0000000..b96748c
--- /dev/null
+++ b/core/src/jvmMain/kotlin/coffee/liz/rookery/bt/JvmAes128.kt
@@ -0,0 +1,17 @@
+package coffee.liz.rookery.bt
+
+import javax.crypto.Cipher
+import javax.crypto.spec.SecretKeySpec
+
+/** [Aes128] over javax.crypto (AES/ECB/NoPadding); works on desktop JVMs and Android. */
+object JvmAes128 : Aes128 {
+    private fun run(mode: Int, key: ByteArray, block: ByteArray): ByteArray {
+        require(key.size == 16 && block.size == 16) { "AES-128 needs a 16-byte key and block" }
+        val c = Cipher.getInstance("AES/ECB/NoPadding")
+        c.init(mode, SecretKeySpec(key, "AES"))
+        return c.doFinal(block)
+    }
+
+    override fun encryptBlock(key: ByteArray, block: ByteArray): ByteArray = run(Cipher.ENCRYPT_MODE, key, block)
+    override fun decryptBlock(key: ByteArray, block: ByteArray): ByteArray = run(Cipher.DECRYPT_MODE, key, block)
+}
diff --git a/core/src/jvmMain/kotlin/coffee/liz/rookery/scramble/TnoodleScrambler.kt b/core/src/jvmMain/kotlin/coffee/liz/rookery/scramble/TnoodleScrambler.kt
new file mode 100644
index 0000000..e0e7b31
--- /dev/null
+++ b/core/src/jvmMain/kotlin/coffee/liz/rookery/scramble/TnoodleScrambler.kt
@@ -0,0 +1,50 @@
+package coffee.liz.rookery.scramble
+
+import coffee.liz.rookery.model.Event
+import org.worldcubeassociation.tnoodle.scrambles.PuzzleRegistry
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.Executors
+import java.util.concurrent.Future
+
+/**
+ * WCA-official random-state scrambles from tnoodle-lib, with one scramble generated ahead per event
+ * so pressing "next" is instant even for 4x4 (whose tables take a few seconds to build).
+ */
+class TnoodleScrambler : Scrambler {
+    private val pool = Executors.newSingleThreadExecutor { r -> Thread(r, "scrambler").apply { isDaemon = true; priority = Thread.MIN_PRIORITY } }
+    private val ahead = ConcurrentHashMap<Event, Future<String>>()
+
+    private fun registry(e: Event): PuzzleRegistry = when (e) {
+        Event.E333, Event.E333OH -> PuzzleRegistry.THREE
+        Event.E222 -> PuzzleRegistry.TWO
+        Event.E444 -> PuzzleRegistry.FOUR
+        Event.E555 -> PuzzleRegistry.FIVE
+        Event.E666 -> PuzzleRegistry.SIX
+        Event.E777 -> PuzzleRegistry.SEVEN
+        Event.E333BF, Event.E333MBF -> PuzzleRegistry.THREE_NI
+        Event.E444BF -> PuzzleRegistry.FOUR_NI
+        Event.E555BF -> PuzzleRegistry.FIVE_NI
+        Event.E333FM -> PuzzleRegistry.THREE_FM
+        Event.CLOCK -> PuzzleRegistry.CLOCK
+        Event.MINX -> PuzzleRegistry.MEGA
+        Event.PYRAM -> PuzzleRegistry.PYRA
+        Event.SKEWB -> PuzzleRegistry.SKEWB
+        Event.SQ1 -> PuzzleRegistry.SQ1
+        Event.FTO -> PuzzleRegistry.FTO
+    }
+
+    private fun submit(e: Event): Future<String> = pool.submit<String> { registry(e).scrambler.generateScramble() }
+
+    override fun warm(event: Event) { ahead.computeIfAbsent(event, ::submit) }
+
+    override fun next(event: Event): String {
+        val f = ahead.remove(event) ?: submit(event)
+        val s = f.get()
+        ahead[event] = submit(event)
+        return s
+    }
+
+    override fun previewSvg(event: Event, scramble: String): String? = runCatching {
+        registry(event).scrambler.drawScramble(scramble, null).toString()
+    }.getOrNull()
+}
diff --git a/core/src/jvmMain/kotlin/coffee/liz/rookery/store/FolderStorage.kt b/core/src/jvmMain/kotlin/coffee/liz/rookery/store/FolderStorage.kt
new file mode 100644
index 0000000..64064b5
--- /dev/null
+++ b/core/src/jvmMain/kotlin/coffee/liz/rookery/store/FolderStorage.kt
@@ -0,0 +1,96 @@
+package coffee.liz.rookery.store
+
+import java.io.RandomAccessFile
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.StandardOpenOption
+import java.security.MessageDigest
+import kotlin.io.path.createDirectories
+import kotlin.io.path.exists
+import kotlin.io.path.isDirectory
+import kotlin.io.path.listDirectoryEntries
+import kotlin.io.path.name
+import kotlin.io.path.readBytes
+import kotlin.io.path.writeBytes
+
+/**
+ * Op log in a plain folder, safe under any file-syncing tool:
+ *
+ * ```
+ * <root>/devices/<nodeId>/ops-000001.jsonl   only <nodeId> ever writes here
+ * <root>/blobs/<sha256>.<ext>                 write-once, content addressed
+ * ```
+ *
+ * Readers remember a byte offset per file and only consume complete lines, so a half-synced
+ * file is simply read again later.
+ */
+class FolderLogStorage(private val root: Path, private val nodeId: String, private val segmentBytes: Long = 8L shl 20) : LogStorage {
+    private val devices = root.resolve("devices")
+    private val ownDir = devices.resolve(nodeId).also { it.createDirectories() }
+    private val offsets = HashMap<Path, Long>()
+
+    private fun currentSegment(): Path {
+        val segs = ownDir.listDirectoryEntries("ops-*.jsonl").sorted()
+        val last = segs.lastOrNull()
+        if (last != null && Files.size(last) < segmentBytes) return last
+        val next = (last?.name?.removePrefix("ops-")?.removeSuffix(".jsonl")?.toIntOrNull() ?: 0) + 1
+        return ownDir.resolve("ops-" + next.toString().padStart(6, '0') + ".jsonl")
+    }
+
+    override fun append(lines: List<String>) {
+        if (lines.isEmpty()) return
+        val bytes = lines.joinToString("\n", postfix = "\n").toByteArray()
+        val seg = currentSegment()
+        Files.newByteChannel(seg, StandardOpenOption.CREATE, StandardOpenOption.APPEND, StandardOpenOption.WRITE).use { ch ->
+            val buf = java.nio.ByteBuffer.wrap(bytes)
+            while (buf.hasRemaining()) ch.write(buf)
+            (ch as? java.nio.channels.FileChannel)?.force(false)
+        }
+        // Our own writes are already applied by the Store; skip them on the next read.
+        offsets[seg] = (offsets[seg] ?: 0) + bytes.size
+    }
+
+    override fun readNew(): List<String> {
+        if (!devices.exists()) return emptyList()
+        val out = mutableListOf<String>()
+        for (dev in devices.listDirectoryEntries().filter { it.isDirectory() }.sorted()) {
+            for (seg in dev.listDirectoryEntries("ops-*.jsonl").sorted()) {
+                val from = offsets[seg] ?: 0
+                val size = Files.size(seg)
+                if (size <= from) continue
+                RandomAccessFile(seg.toFile(), "r").use { f ->
+                    f.seek(from)
+                    val buf = ByteArray((size - from).toInt())
+                    f.readFully(buf)
+                    val end = buf.lastIndexOf('\n'.code.toByte())
+                    if (end < 0) return@use // torn line still syncing
+                    String(buf, 0, end, Charsets.UTF_8).split('\n').filterTo(out) { it.isNotBlank() }
+                    offsets[seg] = from + end + 1
+                }
+            }
+        }
+        return out
+    }
+}
+
+class FolderBlobStore(root: Path) : BlobStore {
+    private val dir = root.resolve("blobs").also { it.createDirectories() }
+
+    override fun put(bytes: ByteArray, ext: String): String {
+        val hash = MessageDigest.getInstance("SHA-256").digest(bytes).joinToString("") { "%02x".format(it) }
+        val name = "$hash.${ext.lowercase().filter(Char::isLetterOrDigit).ifEmpty { "bin" }}"
+        val path = dir.resolve(name)
+        if (!path.exists()) {
+            val tmp = dir.resolve(".$name.tmp")
+            tmp.writeBytes(bytes)
+            Files.move(tmp, path, java.nio.file.StandardCopyOption.ATOMIC_MOVE)
+        }
+        return name
+    }
+
+    override fun get(name: String): ByteArray? {
+        if (name.contains('/') || name.contains("..")) return null
+        val p = dir.resolve(name)
+        return if (p.exists()) p.readBytes() else null
+    }
+}
diff --git a/core/src/jvmTest/kotlin/coffee/liz/rookery/JvmTest.kt b/core/src/jvmTest/kotlin/coffee/liz/rookery/JvmTest.kt
new file mode 100644
index 0000000..ef76184
--- /dev/null
+++ b/core/src/jvmTest/kotlin/coffee/liz/rookery/JvmTest.kt
@@ -0,0 +1,55 @@
+package coffee.liz.rookery
+
+import coffee.liz.rookery.model.Event
+import coffee.liz.rookery.model.Penalty
+import coffee.liz.rookery.model.Solve
+import coffee.liz.rookery.scramble.TnoodleScrambler
+import coffee.liz.rookery.store.FolderBlobStore
+import coffee.liz.rookery.store.FolderLogStorage
+import coffee.liz.rookery.store.Repo
+import coffee.liz.rookery.store.Store
+import java.nio.file.Files
+import kotlin.io.path.appendText
+import kotlin.io.path.listDirectoryEntries
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertTrue
+
+class JvmTest {
+    @Test fun folderSyncBetweenDevicesToleratesTornLines() {
+        val root = Files.createTempDirectory("rookery-sync")
+        fun open(node: String) = Repo(Store(node, FolderLogStorage(root, node), FolderBlobStore(root)) { System.currentTimeMillis() })
+        val a = open("phone")
+        a.addSolve(Solve("s1", "x", Event.E333, 9000, Penalty.NONE, "R", "", 1))
+
+        val b = open("laptop") // fresh device reads everything on startup
+        assertEquals(listOf("s1"), b.solves().map { it.id })
+
+        // simulate Syncthing delivering half of a line from phone
+        val seg = root.resolve("devices/phone").listDirectoryEntries().single()
+        val line = """{"t":"9999999999999-0000-phone","c":"solve","id":"s1","f":"pen","v":"dnf"}"""
+        seg.appendText(line.substring(0, 20))
+        b.store.sync()
+        assertEquals(Penalty.NONE, b.solves().single().penalty)
+        seg.appendText(line.substring(20) + "\n")
+        b.store.sync()
+        assertEquals(Penalty.DNF, b.solves().single().penalty)
+
+        // restart: state rebuilds from disk
+        assertEquals(Penalty.DNF, open("laptop").solves().single().penalty)
+        val blob = a.store.blobs.put(byteArrayOf(1, 2, 3), "jpg")
+        assertEquals(3, open("laptop").store.blobs.get(blob)?.size)
+    }
+
+    /** Runs under the app's 256m heap cap (see core/build.gradle.kts), so this also guards memory. */
+    @Test fun tnoodleScramblesAndDraws() {
+        val s = TnoodleScrambler()
+        for (e in Event.entries) {
+            val scr = s.next(e)
+            assertTrue(scr.isNotBlank(), "$e")
+            val svg = assertNotNull(s.previewSvg(e, scr), "$e svg")
+            assertTrue(svg.contains("<svg"), "$e svg: ${svg.take(80)}")
+        }
+    }
+}
diff --git a/core/src/jvmTest/kotlin/coffee/liz/rookery/TnoodleAgreementTest.kt b/core/src/jvmTest/kotlin/coffee/liz/rookery/TnoodleAgreementTest.kt
new file mode 100644
index 0000000..dd5e9a8
--- /dev/null
+++ b/core/src/jvmTest/kotlin/coffee/liz/rookery/TnoodleAgreementTest.kt
@@ -0,0 +1,103 @@
+package coffee.liz.rookery
+
+import coffee.liz.rookery.puzzle.Puzzles
+import coffee.liz.rookery.puzzle.TwistyPuzzle
+import coffee.liz.rookery.puzzle.V3
+import org.worldcubeassociation.tnoodle.scrambles.PuzzleRegistry
+import kotlin.math.atan2
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+/**
+ * Our 3D models must agree sticker-for-sticker with tnoodle's official 2D drawings. Each model
+ * sticker is mapped onto tnoodle's net through its face (an affine map between the face's 3D and
+ * 2D corners); the colour found there must match ours.
+ */
+class TnoodleAgreementTest {
+    private data class P2(val x: Double, val y: Double)
+    private data class NetSticker(val c: P2, val color: String)
+
+    /** Sticker centroids and fills from a tnoodle SVG, applying each path's transform. */
+    private fun parse(svg: String): List<NetSticker> = Regex("""<path [^>]*>""").findAll(svg).mapNotNull { m ->
+        fun attr(n: String) = Regex("""\b$n="([^"]*)"""").find(m.value)?.groupValues?.get(1)
+        val d = attr("d") ?: return@mapNotNull null
+        val fill = attr("fill") ?: return@mapNotNull null
+        val t = attr("transform")?.let { Regex("""matrix\(([^)]*)\)""").find(it)?.groupValues?.get(1)?.split(',')?.map { v -> v.trim().toDouble() } }
+            ?: listOf(1.0, 0.0, 0.0, 1.0, 0.0, 0.0)
+        val pts = Regex("""[ML] ([-\d.]+) ([-\d.]+)""").findAll(d).map {
+            val x = it.groupValues[1].toDouble(); val y = it.groupValues[2].toDouble()
+            P2(t[0] * x + t[2] * y + t[4], t[1] * x + t[3] * y + t[5])
+        }.toList().distinct()
+        NetSticker(P2(pts.sumOf { it.x } / pts.size, pts.sumOf { it.y } / pts.size), fill)
+    }.toList()
+
+    private fun d2(a: P2, b: P2) = (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y)
+
+    /**
+     * Net face corners, in order around the face: the face's corner stickers pushed outwards from its
+     * centre (corner-sticker centroids sit 2/3 of the way to the corner for both puzzles here).
+     */
+    private fun netCorners(face: List<NetSticker>, n: Int): List<P2> {
+        val cx = face.sumOf { it.c.x } / face.size; val cy = face.sumOf { it.c.y } / face.size
+        return face.sortedByDescending { d2(it.c, P2(cx, cy)) }.take(n)
+            .sortedBy { atan2(it.c.y - cy, it.c.x - cx) }
+            .map { P2(cx + (it.c.x - cx) * 1.5, cy + (it.c.y - cy) * 1.5) }
+    }
+
+    /** Map a point on a 3D face to the net via the face's first three corners (affine). */
+    private fun toNet(p: V3, c3: List<V3>, c2: List<P2>): P2 {
+        val e1 = c3[1] - c3[0]; val e2 = c3[c3.size - 1] - c3[0]; val v = p - c3[0]
+        val d11 = e1 dot e1; val d12 = e1 dot e2; val d22 = e2 dot e2
+        val den = d11 * d22 - d12 * d12
+        val s = ((v dot e1) * d22 - (v dot e2) * d12) / den
+        val t = ((v dot e2) * d11 - (v dot e1) * d12) / den
+        val a = c2[0]; val b = c2[1]; val d = c2[c2.size - 1]
+        return P2(a.x + s * (b.x - a.x) + t * (d.x - a.x), a.y + s * (b.y - a.y) + t * (d.y - a.y))
+    }
+
+    private fun checkAgreement(reg: PuzzleRegistry, model: TwistyPuzzle, faceCorners: List<List<V3>>, faceColors: List<String>) {
+        val scrambler = reg.scrambler
+        val solvedNet = parse(scrambler.drawScramble("", null).toString())
+        val n = faceCorners[0].size
+        val colorIndex = faceColors.withIndex().associate { (i, c) -> c to i }
+
+        fun mismatches(scr: String, mapping: Map<Int, List<P2>>, only: Int? = null): Int {
+            val net = parse(scrambler.drawScramble(scr, null).toString())
+            val st = model.solved().apply(scr)
+            return model.stickers.indices.count { i ->
+                val f = model.stickerFace[i]
+                if (only != null && f != only) return@count false
+                val p = toNet(model.stickers[i].centroid, faceCorners[f], mapping.getValue(f))
+                colorIndex[net.minBy { d2(it.c, p) }.color] != st.colors[i]
+            }
+        }
+
+        // Which net corner is which 3D corner: pick the rotation/reflection that fits reference scrambles
+        // (several, since one scramble can leave a face symmetric enough to tie two alignments)…
+        val refs = List(4) { scrambler.generateScramble() }
+        val mapping = HashMap<Int, List<P2>>()
+        for ((color, face) in solvedNet.groupBy { it.color }) {
+            val f = colorIndex.getValue(color)
+            val c = netCorners(face, n)
+            val options = (0 until n).flatMap { r -> val rot = c.drop(r) + c.take(r); listOf(rot, rot.reversed()) }
+            mapping[f] = options.minBy { opt -> refs.sumOf { mismatches(it, mapping + (f to opt), f) } }
+        }
+        // …then that fixed alignment must hold for fresh scrambles.
+        repeat(15) {
+            val scr = scrambler.generateScramble()
+            assertEquals(0, mismatches(scr, mapping), "${model.name} disagrees with tnoodle on $scr")
+        }
+    }
+
+    @Test fun pyraminxMatchesTnoodle() {
+        val m = Puzzles.pyraminx()
+        val v = m.axes.associate { it.name to it.normal }
+        val corners = listOf(listOf("U", "L", "R"), listOf("U", "L", "B"), listOf("U", "R", "B"), listOf("L", "R", "B")).map { f -> f.map(v::getValue) }
+        checkAgreement(PuzzleRegistry.PYRA, m, corners, listOf("#00ff00", "#ff0000", "#0000ff", "#ffff00"))
+    }
+
+    @Test fun skewbMatchesTnoodle() {
+        val corners = Puzzles.cube(1).stickers.map { it.points }
+        checkAgreement(PuzzleRegistry.SKEWB, Puzzles.skewb(), corners, listOf("#ffffff", "#ff0000", "#00ff00", "#ffff00", "#ff8000", "#0000ff"))
+    }
+}
diff --git a/core/src/jvmTest/kotlin/coffee/liz/rookery/bt/GanCryptoTest.kt b/core/src/jvmTest/kotlin/coffee/liz/rookery/bt/GanCryptoTest.kt
new file mode 100644
index 0000000..a8ad88e
--- /dev/null
+++ b/core/src/jvmTest/kotlin/coffee/liz/rookery/bt/GanCryptoTest.kt
@@ -0,0 +1,40 @@
+package coffee.liz.rookery.bt
+
+import kotlin.test.Test
+import kotlin.test.assertContentEquals
+import kotlin.test.assertFailsWith
+
+@OptIn(ExperimentalStdlibApi::class)
+class GanCryptoTest {
+    // Vectors computed with a Node.js re-implementation of gan-web-bluetooth's GanGen2CubeEncrypter
+    // (aes-js CBC swapped for node:crypto aes-128-cbc, no padding). The MAC is made up; it is chosen so
+    // that key[5] + salt[5] = 0x100, exercising the firmware's `% 0xFF` (255, not 256) salting.
+    private val mac = "6F:F0:12:34:56:78"
+    private val enc = GanEncrypter(JvmAes128, GanDefinitions.GAN_KEY, mac)
+
+    @Test fun saltedKeyAndIv() {
+        assertContentEquals("7958763a220116072005185442111253".hexToByteArray(), enc.key)
+        assertContentEquals("8959663a127076272095781432120243".hexToByteArray(), enc.iv)
+    }
+
+    @Test fun encryptMatchesReference() {
+        val m20 = "030a11181f262d343b424950575e656c737a8188".hexToByteArray()
+        assertContentEquals("f8b5b4a9ac44104f5d5ce7635f869bf95bc95c02".hexToByteArray(), enc.encrypt(m20))
+        val m16 = "fffcf9f6f3f0edeae7e4e1dedbd8d5d2".hexToByteArray()
+        assertContentEquals("c4f8c0629684911cb703cd9a76f44ffb".hexToByteArray(), enc.encrypt(m16))
+    }
+
+    @Test fun roundTrips() {
+        val moyu = GanEncrypter(JvmAes128, GanDefinitions.MOYU_AI_KEY, mac)
+        for (size in listOf(16, 17, 19, 20, 31, 32)) {
+            val msg = ByteArray(size) { (it * 37 + size).toByte() }
+            assertContentEquals(msg, enc.decrypt(enc.encrypt(msg)))
+            assertContentEquals(msg, moyu.decrypt(moyu.encrypt(msg)))
+        }
+    }
+
+    @Test fun rejectsShortMessages() {
+        assertFailsWith<IllegalArgumentException> { enc.encrypt(ByteArray(15)) }
+        assertFailsWith<IllegalArgumentException> { enc.decrypt(ByteArray(15)) }
+    }
+}
diff --git a/core/src/jvmTest/kotlin/coffee/liz/rookery/bt/GanCubeConnectorTest.kt b/core/src/jvmTest/kotlin/coffee/liz/rookery/bt/GanCubeConnectorTest.kt
new file mode 100644
index 0000000..87c5eb4
--- /dev/null
+++ b/core/src/jvmTest/kotlin/coffee/liz/rookery/bt/GanCubeConnectorTest.kt
@@ -0,0 +1,118 @@
+package coffee.liz.rookery.bt
+
+import coffee.liz.rookery.bt.SmartCubeEvent.Facelets
+import coffee.liz.rookery.bt.SmartCubeEvent.Move
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.emptyFlow
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.receiveAsFlow
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.TestScope
+import kotlinx.coroutines.test.runCurrent
+import kotlinx.coroutines.test.runTest
+import kotlin.test.Test
+import kotlin.test.assertContentEquals
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+import kotlin.test.assertTrue
+
+private class FakeConnection(override val address: String, override val name: String?, private val services: List<BleService>) : BleConnection {
+    val notifications = Channel<ByteArray>(Channel.UNLIMITED)
+    val writes = mutableListOf<Triple<String, String, ByteArray>>()
+    val subscribed = mutableListOf<Pair<String, String>>()
+    val gone = CompletableDeferred<Unit>()
+    var disconnectCalls = 0
+
+    override suspend fun discoverServices() = services
+    override suspend fun read(service: String, characteristic: String) = ByteArray(0)
+    override suspend fun write(service: String, characteristic: String, value: ByteArray) { writes += Triple(service, characteristic, value) }
+    override suspend fun subscribe(service: String, characteristic: String): Flow<ByteArray> {
+        subscribed += service to characteristic
+        return notifications.receiveAsFlow()
+    }
+    override val disconnected: Flow<Unit> = flow { gone.await(); emit(Unit) }
+    override suspend fun disconnect() { disconnectCalls++; gone.complete(Unit) }
+}
+
+private class FakeTransport(val conn: FakeConnection) : BleTransport {
+    override fun scan(): Flow<BleAdvertisement> = emptyFlow()
+    override suspend fun connect(address: String): BleConnection { check(address == conn.address); return conn }
+}
+
+class GanCubeConnectorTest {
+    private val mac = "6F:F0:12:34:56:78"
+    private val enc = GanEncrypter(JvmAes128, GanDefinitions.GAN_KEY, mac)
+
+    private fun service(g: GanGeneration) = BleService(g.service, listOf(BleCharacteristic(g.command), BleCharacteristic(g.state)))
+    private val deviceInfo = BleService("0000180a-0000-1000-8000-00805f9b34fb", emptyList())
+
+    private fun TestScope.collect(cube: SmartCube): MutableList<SmartCubeEvent> {
+        val got = mutableListOf<SmartCubeEvent>()
+        backgroundScope.launch(start = CoroutineStart.UNDISPATCHED) { cube.events.collect { got += it } }
+        return got
+    }
+
+    @Test fun gen3EndToEnd() = runTest {
+        val conn = FakeConnection(mac, "GANicV2_1234", listOf(deviceInfo, service(GanGeneration.GEN3)))
+        val cube = GanCubeConnector(FakeTransport(conn), JvmAes128) { 42L }.connect(backgroundScope, mac)
+        assertEquals(GanGeneration.GEN3, (cube as GanSmartCube).generation)
+        assertEquals(listOf(GanDefinitions.GEN3_SERVICE to GanDefinitions.GEN3_STATE), conn.subscribed)
+        val got = collect(cube)
+
+        cube.requestFacelets()
+        val (svc, chr, value) = conn.writes.single()
+        assertEquals(GanDefinitions.GEN3_SERVICE to GanDefinitions.GEN3_COMMAND, svc to chr)
+        assertContentEquals(byteArrayOf(0x68, 0x01) + ByteArray(14), enc.decrypt(value))
+
+        conn.notifications.send(enc.encrypt(Packets.gen3Facelets(3, F_R_STATE)))
+        conn.notifications.send(enc.encrypt(Packets.gen3Move(4, 1, 0, 777)))
+        conn.notifications.send(ByteArray(8)) // too short to decrypt: dropped
+        runCurrent()
+        assertEquals(listOf(Facelets(F_R_FACELETS, 3, F_R_STATE), Move("R", 777, 42, 4)), got)
+
+        conn.gone.complete(Unit) // the cube went away
+        runCurrent()
+        assertEquals(SmartCubeEvent.Disconnected, got.last())
+    }
+
+    @Test fun gen4AndGen2Detection() = runTest {
+        val c4 = FakeConnection(mac, "GAN12uiM_ABCD", listOf(service(GanGeneration.GEN4)))
+        val cube4 = GanCubeConnector(FakeTransport(c4), JvmAes128) { 0L }.connect(backgroundScope, mac) as GanSmartCube
+        assertEquals(GanGeneration.GEN4, cube4.generation)
+        val got = collect(cube4)
+        c4.notifications.send(enc.encrypt(Packets.gen4Facelets(1, SOLVED_STATE)))
+        runCurrent()
+        assertEquals(GanFacelets.SOLVED, (got.single() as Facelets).facelets)
+        cube4.resetToSolved()
+        assertEquals(0xD2.toByte(), enc.decrypt(c4.writes.single().third)[0])
+        cube4.disconnect()
+        runCurrent()
+        assertEquals(1, c4.disconnectCalls)
+        assertEquals(SmartCubeEvent.Disconnected, got.last())
+
+        val c2 = FakeConnection(mac, "GAN-1234", listOf(service(GanGeneration.GEN2)))
+        val cube2 = GanCubeConnector(FakeTransport(c2), JvmAes128) { 0L }.connect(backgroundScope, mac) as GanSmartCube
+        assertEquals(GanGeneration.GEN2, cube2.generation)
+        cube2.requestBattery()
+        assertEquals(0x09, enc.decrypt(c2.writes.single().third)[0].toInt())
+        cube2.disconnect()
+    }
+
+    @Test fun moyuAiUsesItsOwnKey() = runTest {
+        val c = FakeConnection(mac, "AiCube_0001", listOf(service(GanGeneration.GEN2)))
+        val cube = GanCubeConnector(FakeTransport(c), JvmAes128) { 0L }.connect(backgroundScope, mac)
+        cube.requestHardware()
+        val moyu = GanEncrypter(JvmAes128, GanDefinitions.MOYU_AI_KEY, mac)
+        assertEquals(0x05, moyu.decrypt(c.writes.single().third)[0].toInt())
+        cube.disconnect()
+    }
+
+    @Test fun unknownDeviceIsRejectedAndDisconnected() = runTest {
+        val c = FakeConnection(mac, "Speaker", listOf(deviceInfo))
+        assertFailsWith<IllegalStateException> { GanCubeConnector(FakeTransport(c), JvmAes128).connect(backgroundScope, mac) }
+        assertTrue(c.disconnectCalls == 1)
+    }
+}
diff --git a/desktop/build.gradle.kts b/desktop/build.gradle.kts
new file mode 100644
index 0000000..d143c5f
--- /dev/null
+++ b/desktop/build.gradle.kts
@@ -0,0 +1,30 @@
+import org.jetbrains.compose.desktop.application.dsl.TargetFormat
+
+plugins {
+    alias(libs.plugins.kotlin.jvm)
+    alias(libs.plugins.kotlin.compose)
+    alias(libs.plugins.compose)
+}
+
+kotlin { jvmToolchain(21) }
+
+dependencies {
+    implementation(project(":ui"))
+    implementation(compose.desktop.currentOs)
+    implementation(libs.coroutines.swing)
+}
+
+compose.desktop {
+    application {
+        mainClass = "coffee.liz.rookery.desktop.MainKt"
+        jvmArgs += listOf("-Xmx256m", "-XX:+UseSerialGC")
+        nativeDistributions {
+            targetFormats(TargetFormat.AppImage, TargetFormat.Deb)
+            packageName = "rookery"
+            packageVersion = "0.1.0"
+        }
+    }
+}
+
+// `./gradlew :desktop:run --args="--import file.txt"` passes args through; env lets tests point at a scratch home.
+tasks.withType<JavaExec>().configureEach { environment.putAll(System.getenv().filterKeys { it.startsWith("XDG_") || it.startsWith("ROOKERY_") }) }
diff --git a/desktop/src/main/kotlin/coffee/liz/rookery/desktop/CubeCli.kt b/desktop/src/main/kotlin/coffee/liz/rookery/desktop/CubeCli.kt
new file mode 100644
index 0000000..b183420
--- /dev/null
+++ b/desktop/src/main/kotlin/coffee/liz/rookery/desktop/CubeCli.kt
@@ -0,0 +1,80 @@
+package coffee.liz.rookery.desktop
+
+import coffee.liz.rookery.bt.BleAdvertisement
+import coffee.liz.rookery.bt.BlueZTransport
+import coffee.liz.rookery.bt.GanCubeConnector
+import coffee.liz.rookery.bt.GanSmartCube
+import coffee.liz.rookery.bt.JvmAes128
+import coffee.liz.rookery.bt.SmartCubeEvent
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeoutOrNull
+import kotlin.system.exitProcess
+
+/**
+ * `rookery --cube scan [seconds] [--all]` lists nearby GAN smart cubes (or every BLE device) for ~10 s.
+ * `rookery --cube monitor <MAC>` connects and streams moves until Ctrl-C.
+ */
+fun cubeCli(args: List<String>) {
+    val usage = "usage: --cube scan [seconds] [--all] | --cube monitor <MAC>"
+    when (args.firstOrNull()) {
+        "scan" -> scan(args.getOrNull(1)?.toLongOrNull() ?: 10, all = "--all" in args)
+        "monitor" -> monitor(args.getOrNull(1) ?: run { System.err.println(usage); exitProcess(2) })
+        else -> { System.err.println(usage); exitProcess(2) }
+    }
+    exitProcess(0)
+}
+
+private fun scan(seconds: Long, all: Boolean) = BlueZTransport().use { transport ->
+    println("Scanning for ${if (all) "BLE devices" else "GAN cubes"} for $seconds s...")
+    val seen = LinkedHashMap<String, BleAdvertisement>()
+    runBlocking {
+        withTimeoutOrNull(seconds * 1000) {
+            transport.scan().collect { adv ->
+                if (!all && !GanCubeConnector.isGanCube(adv)) return@collect
+                if (adv.address !in seen) println("  found ${adv.name ?: "?"}  ${adv.address}  rssi ${adv.rssi ?: "?"}")
+                seen[adv.address] = adv
+            }
+        }
+    }
+    if (seen.isEmpty()) println(if (all) "No BLE devices found." else "No GAN cubes found (turn the cube a little to wake it).")
+    else {
+        println("${seen.size} ${if (all) "device" else "cube"}(s):")
+        seen.values.forEach { println("  ${it.name ?: "?"}\t${it.address}\trssi ${it.rssi ?: "?"}") }
+    }
+}
+
+private fun monitor(mac: String) = BlueZTransport().use { transport ->
+    runBlocking {
+        println("Connecting to $mac...")
+        val cube = GanCubeConnector(transport, JvmAes128).connect(this, mac)
+        println("Connected: ${cube.name ?: "?"} (${(cube as? GanSmartCube)?.generation ?: "?"})")
+        val done = CompletableDeferred<Unit>()
+        Runtime.getRuntime().addShutdownHook(Thread { runBlocking { withTimeoutOrNull(2000) { cube.disconnect() } } })
+        var firstMoveHost: Long? = null
+        val collector = launch(start = CoroutineStart.UNDISPATCHED) {
+            cube.events.collect { e ->
+                when (e) {
+                    is SmartCubeEvent.Move -> {
+                        val t0 = firstMoveHost ?: e.hostTimestampMs.also { firstMoveHost = it }
+                        println("move %-3s host +%6d ms  cube %s%s".format(e.move, e.hostTimestampMs - t0, e.cubeTimestampMs?.let { "$it ms" } ?: "-", if (e.recovered) "  (recovered)" else ""))
+                    }
+                    is SmartCubeEvent.Facelets -> println("facelets ${e.facelets}")
+                    is SmartCubeEvent.Battery -> println("battery ${e.percent}%")
+                    is SmartCubeEvent.Hardware -> println("hardware ${e.name} hw ${e.hardwareVersion} sw ${e.softwareVersion}" + (e.productDate?.let { " made $it" } ?: "") + if (e.gyroSupported) " gyro" else "")
+                    is SmartCubeEvent.Gyro -> Unit // too chatty to print
+                    SmartCubeEvent.Disconnected -> { println("disconnected"); done.complete(Unit) }
+                }
+            }
+        }
+        cube.requestHardware(); delay(300)
+        cube.requestBattery(); delay(300)
+        cube.requestFacelets()
+        println("Streaming moves; Ctrl-C to quit.")
+        done.await()
+        collector.cancel()
+    }
+}
diff --git a/desktop/src/main/kotlin/coffee/liz/rookery/desktop/Main.kt b/desktop/src/main/kotlin/coffee/liz/rookery/desktop/Main.kt
new file mode 100644
index 0000000..60d7443
--- /dev/null
+++ b/desktop/src/main/kotlin/coffee/liz/rookery/desktop/Main.kt
@@ -0,0 +1,147 @@
+package coffee.liz.rookery.desktop
+
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.unit.DpSize
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Window
+import androidx.compose.ui.window.application
+import androidx.compose.ui.window.rememberWindowState
+import coffee.liz.rookery.audio.Chime
+import coffee.liz.rookery.audio.ChimePlayer
+import coffee.liz.rookery.model.Event
+import coffee.liz.rookery.scramble.TnoodleScrambler
+import coffee.liz.rookery.store.FolderBlobStore
+import coffee.liz.rookery.store.FolderLogStorage
+import coffee.liz.rookery.store.Repo
+import coffee.liz.rookery.store.Store
+import coffee.liz.rookery.ui.AppModel
+import coffee.liz.rookery.ui.Host
+import coffee.liz.rookery.ui.RookeryApp
+import coffee.liz.rookery.ui.handleTimerKey
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.awt.FileDialog
+import java.awt.Frame
+import java.nio.file.Path
+import java.nio.file.Paths
+import java.util.Properties
+import java.util.zip.ZipFile
+import javax.swing.JFileChooser
+import kotlin.io.path.createDirectories
+import kotlin.io.path.exists
+import kotlin.io.path.inputStream
+import kotlin.io.path.outputStream
+import kotlin.io.path.readBytes
+
+/** Per-machine settings (never synced): which folder to sync, and this device's id. */
+class LocalConfig {
+    private val dir: Path = (System.getenv("XDG_CONFIG_HOME")?.let { Paths.get(it) } ?: Paths.get(System.getProperty("user.home"), ".config")).resolve("rookery")
+    private val file = dir.resolve("config.properties")
+    private val props = Properties().apply { if (file.exists()) file.inputStream().use { load(it) } }
+
+    private fun save() { dir.createDirectories(); file.outputStream().use { props.store(it, "rookery local config") } }
+
+    val deviceId: String = props.getProperty("deviceId") ?: run {
+        val host = runCatching { java.net.InetAddress.getLocalHost().hostName }.getOrNull()?.filter { it.isLetterOrDigit() || it == '-' }?.take(24) ?: "desktop"
+        "$host-${coffee.liz.rookery.randomId().take(6)}".also { props.setProperty("deviceId", it); save() }
+    }
+
+    var syncFolder: String
+        get() = props.getProperty("syncFolder") ?: defaultData().resolve("sync").toString()
+        set(v) { props.setProperty("syncFolder", v); save() }
+
+    private fun defaultData(): Path =
+        (System.getenv("XDG_DATA_HOME")?.let { Paths.get(it) } ?: Paths.get(System.getProperty("user.home"), ".local", "share")).resolve("rookery")
+}
+
+class DesktopHost(private val config: LocalConfig) : Host {
+    override fun playChime(notes: List<Chime.Note>) = ChimePlayer.play(notes)
+
+    override suspend fun pickFile(title: String, extensions: List<String>): String? = withContext(Dispatchers.Main) {
+        val d = FileDialog(null as Frame?, title, FileDialog.LOAD)
+        d.setFilenameFilter { _, name -> extensions.any { name.lowercase().endsWith(".$it") } }
+        d.isVisible = true
+        d.file?.let { Paths.get(d.directory, it).toString() }
+    }
+
+    override suspend fun pickFolder(title: String): String? = withContext(Dispatchers.Main) {
+        val c = JFileChooser(config.syncFolder).apply { dialogTitle = title; fileSelectionMode = JFileChooser.DIRECTORIES_ONLY }
+        if (c.showOpenDialog(null) == JFileChooser.APPROVE_OPTION) c.selectedFile.absolutePath else null
+    }
+
+    override suspend fun readFile(path: String): ByteArray = withContext(Dispatchers.IO) { Paths.get(path).readBytes() }
+
+    override suspend fun readImport(path: String, mainEntry: String?): Pair<String, (String) -> ByteArray?> = withContext(Dispatchers.IO) {
+        if (!path.lowercase().endsWith(".zip")) {
+            val dir = Paths.get(path).parent
+            Paths.get(path).readBytes().decodeToString() to { rel: String -> dir.resolve(rel).normalize().takeIf { it.startsWith(dir) && it.exists() }?.readBytes() }
+        } else {
+            // Read everything up front so the loader works after the zip is closed.
+            val entries = ZipFile(path).use { z -> z.entries().toList().filter { !it.isDirectory }.associate { it.name to z.getInputStream(it).readBytes() } }
+            val main = entries.entries.firstOrNull { it.key == mainEntry || it.key.endsWith("/$mainEntry") }
+                ?: error("no $mainEntry in ${Paths.get(path).fileName}")
+            val prefix = main.key.removeSuffix(mainEntry ?: "")
+            main.value.decodeToString() to { rel: String -> entries[prefix + rel] }
+        }
+    }
+
+    override val syncFolder: String get() = config.syncFolder
+    override fun setSyncFolder(path: String) { config.syncFolder = path }
+    override val deviceId: String get() = config.deviceId
+}
+
+fun main(args: Array<String>) {
+    if (args.firstOrNull() == "--import") return headlessImport(args.drop(1))
+    if (args.firstOrNull() == "--cube") return cubeCli(args.drop(1))
+    System.setProperty("skiko.renderApi", System.getProperty("skiko.renderApi") ?: "OPENGL")
+    val config = LocalConfig()
+    val root = Paths.get(config.syncFolder).also { it.createDirectories() }
+    val store = Store(config.deviceId, FolderLogStorage(root, config.deviceId), FolderBlobStore(root), System::currentTimeMillis)
+    val repo = Repo(store)
+    val scrambler = TnoodleScrambler().apply { warm(Event.E333) }
+
+    application {
+        val state = rememberWindowState(size = DpSize(1280.dp, 820.dp))
+        val scope = rememberCoroutineScope()
+        val model = remember {
+            AppModel(repo, scrambler, DesktopHost(config), scope).apply {
+                // dev hooks for screenshots: ROOKERY_TAB=PAIRS, ROOKERY_PARTY=1, ROOKERY_REPLAY=1, ROOKERY_EVENT=pyram
+                System.getenv("ROOKERY_TAB")?.let { t -> coffee.liz.rookery.ui.Tab.entries.firstOrNull { it.name == t }?.let { tab = it } }
+                System.getenv("ROOKERY_EVENT")?.let { id -> Event.byId(id)?.let { e -> scope.launch { kotlinx.coroutines.delay(1500); createSession(e) } } }
+                if (System.getenv("ROOKERY_REPLAY") != null) scope.launch {
+                    kotlinx.coroutines.delay(4000)
+                    derived.sessionSolves.lastOrNull { it.moves != null }?.let { selectedSolveId = it.id; startReplay(it) }
+                }
+                if (System.getenv("ROOKERY_PARTY") != null) scope.launch { kotlinx.coroutines.delay(5000); testParty() }
+            }
+        }
+        Window(
+            onCloseRequest = ::exitApplication, state = state, title = "rookery",
+            onPreviewKeyEvent = { handleTimerKey(model, it) },
+        ) {
+            RookeryApp(model)
+        }
+    }
+}
+
+/** `rookery --import <file>...`: import csTimer .txt or Letter Pair Gym .zip files without opening a window. */
+private fun headlessImport(paths: List<String>) {
+    val config = LocalConfig()
+    val root = Paths.get(config.syncFolder).also { it.createDirectories() }
+    val repo = Repo(Store(config.deviceId, FolderLogStorage(root, config.deviceId), FolderBlobStore(root), System::currentTimeMillis))
+    val host = DesktopHost(config)
+    val importer = coffee.liz.rookery.importer.Importer(repo)
+    for (p in paths) {
+        println("» $p")
+        val summary = kotlinx.coroutines.runBlocking {
+            if (p.lowercase().endsWith(".zip") || p.endsWith("backup.json")) {
+                val (text, files) = host.readImport(p, "backup.json")
+                importer.letterPairGym(text, files)
+            } else importer.csTimer(host.readFile(p).decodeToString())
+        }
+        summary.lines.forEach { println("  ✓ $it") }
+        summary.warnings.forEach { println("  ! $it") }
+    }
+}
diff --git a/gradle.properties b/gradle.properties
new file mode 100644
index 0000000..85a128d
--- /dev/null
+++ b/gradle.properties
@@ -0,0 +1,8 @@
+# Sized for small machines (this is developed on a 4 GB laptop): one modest Gradle heap,
+# Kotlin compiled inside it rather than in a second daemon, and only two workers at a time.
+org.gradle.jvmargs=-Xmx1280m -XX:MaxMetaspaceSize=384m -XX:+UseSerialGC -Dfile.encoding=UTF-8
+kotlin.compiler.execution.strategy=in-process
+org.gradle.workers.max=2
+org.gradle.caching=true
+org.gradle.configuration-cache=true
+kotlin.code.style=official
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
new file mode 100644
index 0000000..afef406
--- /dev/null
+++ b/gradle/libs.versions.toml
@@ -0,0 +1,27 @@
+[versions]
+kotlin = "2.4.21"
+compose = "1.12.2"
+coroutines = "1.11.0"
+serialization = "1.13.0"
+tnoodle = "0.20.0"
+dbus-java = "5.2.2"
+
+[libraries]
+coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "coroutines" }
+coroutines-swing = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-swing", version.ref = "coroutines" }
+coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "coroutines" }
+serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "serialization" }
+tnoodle-scrambles = { module = "org.worldcubeassociation.tnoodle:lib-scrambles", version.ref = "tnoodle" }
+dbus-java-core = { module = "com.github.hypfvieh:dbus-java-core", version.ref = "dbus-java" }
+dbus-java-transport-native = { module = "com.github.hypfvieh:dbus-java-transport-native-unixsocket", version.ref = "dbus-java" }
+compose-runtime = { module = "org.jetbrains.compose.runtime:runtime", version.ref = "compose" }
+compose-foundation = { module = "org.jetbrains.compose.foundation:foundation", version.ref = "compose" }
+compose-ui = { module = "org.jetbrains.compose.ui:ui", version.ref = "compose" }
+compose-resources = { module = "org.jetbrains.compose.components:components-resources", version.ref = "compose" }
+
+[plugins]
+kotlin-multiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
+kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
+kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
+kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
+compose = { id = "org.jetbrains.compose", version.ref = "compose" }
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000..51cbd2a
--- /dev/null
+++ b/gradle/wrapper/gradle-wrapper.jar
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000..04d7959
--- /dev/null
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,9 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.9.1-bin.zip
+networkTimeout=10000
+retries=0
+retryBackOffMs=500
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/gradlew b/gradlew
new file mode 100755
index 0000000..249efbb
--- /dev/null
+++ b/gradlew
@@ -0,0 +1,248 @@
+#!/bin/sh
+
+#
+# Copyright © 2015 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+##############################################################################
+#
+#   gradlew start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh gradlew
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/3d91ce3b8caaf77ad09f381f43615b715b53f72c/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"
diff --git a/gradlew.bat b/gradlew.bat
new file mode 100644
index 0000000..03754c4
--- /dev/null
+++ b/gradlew.bat
@@ -0,0 +1,112 @@
+@rem

+@rem Copyright 2015 the original author or authors.

+@rem

+@rem Licensed under the Apache License, Version 2.0 (the "License");

+@rem you may not use this file except in compliance with the License.

+@rem You may obtain a copy of the License at

+@rem

+@rem      https://www.apache.org/licenses/LICENSE-2.0

+@rem

+@rem Unless required by applicable law or agreed to in writing, software

+@rem distributed under the License is distributed on an "AS IS" BASIS,

+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+@rem See the License for the specific language governing permissions and

+@rem limitations under the License.

+@rem

+@rem SPDX-License-Identifier: Apache-2.0

+@rem

+

+@if "%DEBUG%"=="" @echo off

+@rem ##########################################################################

+@rem

+@rem  gradlew startup script for Windows

+@rem

+@rem ##########################################################################

+

+@rem Set local scope for the variables, and ensure extensions are enabled

+setlocal EnableExtensions

+

+@rem Catch executions from older scripts and ensure they exit cleanly.

+@rem This can be removed once we can be reasonably confident that few people

+@rem will be migrating directly to this new wrapper.

+goto afterSafetyNet

+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

+goto exitWithErrorLevel

+:afterSafetyNet

+

+set DIRNAME=%~dp0

+if "%DIRNAME%"=="" set DIRNAME=.

+@rem This is normally unused

+set APP_BASE_NAME=%~n0

+set APP_HOME=%DIRNAME%

+

+@rem Resolve any "." and ".." in APP_HOME to make it shorter.

+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi

+

+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.

+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"

+

+@rem Find java.exe

+if defined JAVA_HOME goto findJavaFromJavaHome

+

+set JAVA_EXE=java.exe

+%JAVA_EXE% -version >NUL 2>&1

+if %ERRORLEVEL% equ 0 goto execute

+

+1>&2 echo.

+1>&2 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.

+1>&2 echo.

+1>&2 echo Please set the JAVA_HOME variable in your environment to match the

+1>&2 echo location of your Java installation.

+

+"%COMSPEC%" /c exit 1

+goto exitWithErrorLevel

+

+:findJavaFromJavaHome

+set JAVA_HOME=%JAVA_HOME:"=%

+set JAVA_EXE=%JAVA_HOME%/bin/java.exe

+

+if exist "%JAVA_EXE%" goto execute

+

+1>&2 echo.

+1>&2 echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%

+1>&2 echo.

+1>&2 echo Please set the JAVA_HOME variable in your environment to match the

+1>&2 echo location of your Java installation.

+

+"%COMSPEC%" /c exit 1

+goto exitWithErrorLevel

+

+:execute

+@rem Setup the command line

+

+

+

+@rem Execute gradlew

+@rem endlocal doesn't take effect until after the line is parsed and variables are expanded

+@rem which allows us to clear the local environment before executing the java command

+endlocal & "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %* & call :exitWithErrorLevel & goto exitWithErrorLevel

+

+@rem This label must not be changed. We rely on old scripts being able to jump to this point.

+:exitWithErrorLevel

+@rem Use "%COMSPEC%" /c exit to allow operators to work properly in scripts

+"%COMSPEC%" /c exit %ERRORLEVEL%

diff --git a/settings.gradle.kts b/settings.gradle.kts
new file mode 100644
index 0000000..cae62dd
--- /dev/null
+++ b/settings.gradle.kts
@@ -0,0 +1,18 @@
+rootProject.name = "rookery"
+
+pluginManagement {
+    repositories {
+        gradlePluginPortal()
+        mavenCentral()
+        google()
+    }
+}
+
+dependencyResolutionManagement {
+    repositories {
+        mavenCentral()
+        google()
+    }
+}
+
+include(":core", ":ui", ":desktop")
diff --git a/ui/build.gradle.kts b/ui/build.gradle.kts
new file mode 100644
index 0000000..28e4ef6
--- /dev/null
+++ b/ui/build.gradle.kts
@@ -0,0 +1,26 @@
+plugins {
+    alias(libs.plugins.kotlin.multiplatform)
+    alias(libs.plugins.kotlin.compose)
+    alias(libs.plugins.compose)
+}
+
+kotlin {
+    jvmToolchain(21)
+    jvm()
+
+    sourceSets {
+        commonMain.dependencies {
+            api(project(":core"))
+            api(libs.compose.runtime)
+            api(libs.compose.foundation)
+            api(libs.compose.ui)
+            implementation(libs.compose.resources)
+            implementation(libs.coroutines.core)
+        }
+    }
+}
+
+compose.resources {
+    publicResClass = false
+    packageOfResClass = "coffee.liz.rookery.ui.res"
+}
diff --git a/ui/src/commonMain/composeResources/drawable/penguin_sheet.png b/ui/src/commonMain/composeResources/drawable/penguin_sheet.png
new file mode 100644
index 0000000..24670c1
--- /dev/null
+++ b/ui/src/commonMain/composeResources/drawable/penguin_sheet.png
diff --git a/ui/src/commonMain/composeResources/font/silkscreen.ttf b/ui/src/commonMain/composeResources/font/silkscreen.ttf
new file mode 100644
index 0000000..8caff81
--- /dev/null
+++ b/ui/src/commonMain/composeResources/font/silkscreen.ttf
diff --git a/ui/src/commonMain/composeResources/font/silkscreen_bold.ttf b/ui/src/commonMain/composeResources/font/silkscreen_bold.ttf
new file mode 100644
index 0000000..6771252
--- /dev/null
+++ b/ui/src/commonMain/composeResources/font/silkscreen_bold.ttf
diff --git a/ui/src/commonMain/composeResources/font/vt323.ttf b/ui/src/commonMain/composeResources/font/vt323.ttf
new file mode 100644
index 0000000..afa6909
--- /dev/null
+++ b/ui/src/commonMain/composeResources/font/vt323.ttf
diff --git a/ui/src/commonMain/kotlin/coffee/liz/rookery/ui/App.kt b/ui/src/commonMain/kotlin/coffee/liz/rookery/ui/App.kt
new file mode 100644
index 0000000..3cc79dd
--- /dev/null
+++ b/ui/src/commonMain/kotlin/coffee/liz/rookery/ui/App.kt
@@ -0,0 +1,70 @@
+package coffee.liz.rookery.ui
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.input.key.KeyEvent
+import androidx.compose.ui.input.key.KeyEventType
+import androidx.compose.ui.input.key.isCtrlPressed
+import androidx.compose.ui.input.key.key
+import androidx.compose.ui.input.key.type
+import androidx.compose.ui.unit.dp
+import coffee.liz.rookery.model.Penalty
+import coffee.liz.rookery.timer.TimerMachine.State
+
+@Composable
+fun RookeryApp(m: AppModel) {
+    val dark = when (m.themeMode) { ThemeMode.SYSTEM -> isSystemInDarkTheme(); ThemeMode.LIGHT -> false; ThemeMode.DARK -> true }
+    RookeryTheme(dark) {
+        Box(Modifier.fillMaxSize().background(Rk.c.bg)) {
+            Column(Modifier.fillMaxSize()) {
+                TitleBar("🐧 rookery · ${m.tab.label.lowercase()}")
+                Tabs(Tab.entries, m.tab, { it.label }, { m.tab = it })
+                Box(Modifier.weight(1f).fillMaxWidth().padding(horizontal = 6.dp).padding(bottom = 6.dp).background(Rk.c.panel).bevel(Rk.c)) {
+                    when (m.tab) {
+                        Tab.TIMER -> TimerScreen(m)
+                        Tab.PAIRS -> PairsScreen(m)
+                        Tab.IMPORT -> ImportScreen(m)
+                        Tab.SETTINGS -> SettingsScreen(m)
+                    }
+                }
+            }
+            m.party?.let { PbParty(it.title, it.detail, m.reducedMotion) { m.party = null } }
+        }
+    }
+}
+
+/**
+ * Window-level keys for the timer, csTimer-style: space starts, any key stops, Esc cancels,
+ * Ctrl+1/2/3 set OK/+2/DNF on the last solve. Returns true if consumed.
+ */
+fun handleTimerKey(m: AppModel, e: KeyEvent): Boolean {
+    if (m.tab != Tab.TIMER) return false
+    val running = m.timer is State.Running
+    if (e.isCtrlPressed && e.type == KeyEventType.KeyDown) {
+        val last = m.lastSolve() ?: return false
+        when (e.key) {
+            Key.One -> m.setPenalty(last.id, Penalty.NONE)
+            Key.Two -> m.setPenalty(last.id, Penalty.PLUS2)
+            Key.Three -> m.setPenalty(last.id, Penalty.DNF)
+            else -> return false
+        }
+        return true
+    }
+    return when {
+        e.key == Key.Escape && e.type == KeyEventType.KeyDown -> { m.cancel(); true }
+        running && e.type == KeyEventType.KeyDown -> { m.press(); true }
+        e.key == Key.Spacebar && e.type == KeyEventType.KeyDown -> { m.press(); true }
+        e.key == Key.Spacebar && e.type == KeyEventType.KeyUp -> { m.release(); true }
+        // release after stopping with a non-space key
+        m.timer is State.Stopped && e.type == KeyEventType.KeyUp -> { m.release(); true }
+        else -> false
+    }
+}
diff --git a/ui/src/commonMain/kotlin/coffee/liz/rookery/ui/AppModel.kt b/ui/src/commonMain/kotlin/coffee/liz/rookery/ui/AppModel.kt
new file mode 100644
index 0000000..db34c7b
--- /dev/null
+++ b/ui/src/commonMain/kotlin/coffee/liz/rookery/ui/AppModel.kt
@@ -0,0 +1,305 @@
+package coffee.liz.rookery.ui
+
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableLongStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import coffee.liz.rookery.audio.Chime
+import coffee.liz.rookery.epochMillis
+import coffee.liz.rookery.importer.Importer
+import coffee.liz.rookery.model.DNF
+import coffee.liz.rookery.model.Event
+import coffee.liz.rookery.model.LetterPair
+import coffee.liz.rookery.model.Penalty
+import coffee.liz.rookery.model.Session
+import coffee.liz.rookery.model.Solve
+import coffee.liz.rookery.model.formatTime
+import coffee.liz.rookery.monoMillis
+import coffee.liz.rookery.puzzle.PuzzleState
+import coffee.liz.rookery.puzzle.Puzzles
+import coffee.liz.rookery.puzzle.Turn
+import coffee.liz.rookery.randomId
+import coffee.liz.rookery.scramble.Scrambler
+import coffee.liz.rookery.stats.PersonalBest
+import coffee.liz.rookery.stats.StatKind
+import coffee.liz.rookery.stats.StatSummary
+import coffee.liz.rookery.stats.newPersonalBests
+import coffee.liz.rookery.store.Repo
+import coffee.liz.rookery.timer.TimerMachine
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+/** What the UI needs from the platform it runs on. */
+interface Host {
+    fun playChime(notes: List<Chime.Note>)
+    /** Ask the user for a file; returns its path, or null if cancelled. */
+    suspend fun pickFile(title: String, extensions: List<String>): String?
+    suspend fun pickFolder(title: String): String?
+    /** Read an import file, handling zips: returns the main text and a loader for files inside it. */
+    suspend fun readImport(path: String, mainEntry: String?): Pair<String, (String) -> ByteArray?>
+    suspend fun readFile(path: String): ByteArray
+    val syncFolder: String
+    fun setSyncFolder(path: String)
+    val deviceId: String
+}
+
+enum class Tab(val label: String) { TIMER("Timer"), PAIRS("Letter pairs"), IMPORT("Import"), SETTINGS("Settings") }
+enum class ThemeMode { SYSTEM, LIGHT, DARK }
+
+/** Everything derived from the store, recomputed off the UI thread when it changes. */
+data class Derived(
+    val sessions: List<Session> = emptyList(),
+    val session: Session? = null,
+    val sessionSolves: List<Solve> = emptyList(),
+    val sessionStats: StatSummary = StatSummary.of(emptyList()),
+    /** Lifetime stats for the session's event, across all sessions: what PBs are measured against. */
+    val eventStats: StatSummary = StatSummary.of(emptyList()),
+    val pairs: Map<String, LetterPair> = emptyMap(),
+)
+
+data class Party(val title: String, val detail: String)
+
+/** A smart-cube solve being played back in 3D. */
+data class Replay(
+    val solveId: String,
+    val state: PuzzleState,
+    val anim: TurnAnim?,
+    val index: Int,
+    val total: Int,
+    val elapsedMs: Long,
+    val playing: Boolean,
+    /** Set when playback finishes: did the moves actually solve the scramble? */
+    val endedSolved: Boolean? = null,
+)
+
+class AppModel(val repo: Repo, private val scrambler: Scrambler, val host: Host, private val scope: CoroutineScope) {
+    var tab by mutableStateOf(Tab.TIMER)
+    var derived by mutableStateOf(Derived())
+        private set
+    var sessionId by mutableStateOf(repo.pref("lastSession"))
+        private set
+
+    val machine = TimerMachine()
+    var timer by mutableStateOf<TimerMachine.State>(TimerMachine.State.Idle)
+        private set
+    var now by mutableLongStateOf(0)
+        private set
+    var lastActivity by mutableLongStateOf(monoMillis())
+        private set
+
+    var scramble by mutableStateOf("")
+        private set
+    var previewSvg by mutableStateOf<String?>(null)
+        private set
+    /** 3D state of the current scramble, for puzzles that have a model. */
+    var previewState by mutableStateOf<PuzzleState?>(null)
+        private set
+    var replay by mutableStateOf<Replay?>(null)
+        private set
+    private var replayJob: kotlinx.coroutines.Job? = null
+    var party by mutableStateOf<Party?>(null)
+    var lastPbs by mutableStateOf<List<PersonalBest>>(emptyList())
+        private set
+    var lastSolveId by mutableStateOf<String?>(null)
+        private set
+    var selectedSolveId by mutableStateOf<String?>(null)
+
+    var inspection by mutableStateOf(repo.boolPref("inspection", true)); private set
+    var sound by mutableStateOf(repo.boolPref("sound", true)); private set
+    var reducedMotion by mutableStateOf(repo.boolPref("reducedMotion", false)); private set
+    var themeMode by mutableStateOf(ThemeMode.entries.firstOrNull { it.name == repo.pref("theme") } ?: ThemeMode.SYSTEM); private set
+
+    var importLog by mutableStateOf<List<String>>(emptyList())
+
+    init {
+        machine.inspection = inspection
+        machine.onFinish = ::finishSolve
+        scope.launch { repo.store.version.collect { refresh() } }
+        scope.launch {
+            // Pick up ops other devices wrote into the sync folder.
+            while (true) { delay(2000); withContext(Dispatchers.Default) { repo.store.sync() } }
+        }
+    }
+
+    val event: Event get() = derived.session?.event ?: Event.E333
+
+    private suspend fun refresh() {
+        val wanted = sessionId
+        val d = withContext(Dispatchers.Default) {
+            val sessions = repo.sessions()
+            val session = sessions.firstOrNull { it.id == wanted } ?: sessions.lastOrNull()
+            val all = repo.solves()
+            val inSession = all.filter { it.sessionId == session?.id }
+            val inEvent = all.filter { it.event == session?.event }
+            Derived(sessions, session, inSession, StatSummary.of(inSession.map { it.result }), StatSummary.of(inEvent.map { it.result }), repo.letterPairs())
+        }
+        if (d.session == null) {
+            createSession(Event.E333)
+            return
+        }
+        val eventChanged = d.session.event != derived.session?.event
+        derived = d
+        if (sessionId != d.session.id) sessionId = d.session.id
+        if (eventChanged || scramble.isEmpty()) newScramble()
+    }
+
+    fun selectSession(id: String) {
+        sessionId = id
+        repo.setPref("lastSession", id)
+        scope.launch { refresh() }
+    }
+
+    fun createSession(event: Event) {
+        val id = randomId()
+        val count = derived.sessions.count { it.event == event }
+        repo.createSession(id, if (count == 0) "Main ${event.short}" else "${event.short} #${count + 1}", event, epochMillis())
+        selectSession(id)
+    }
+
+    fun newScramble() {
+        val e = event
+        scramble = "…"
+        previewSvg = null
+        previewState = null
+        scope.launch {
+            val s = withContext(Dispatchers.Default) { scrambler.next(e) }
+            val svg = withContext(Dispatchers.Default) { scrambler.previewSvg(e, s) }
+            val st = withContext(Dispatchers.Default) { runCatching { Puzzles.of(e.puzzle)?.solved()?.apply(s) }.getOrNull() }
+            if (event == e) { scramble = s; previewSvg = svg; previewState = st }
+        }
+    }
+
+    // ---- timer input ----
+
+    private fun sync() { timer = machine.state; lastActivity = monoMillis() }
+
+    fun press() { machine.press(monoMillis()); sync() }
+    fun release() { machine.release(monoMillis()); sync() }
+    fun cancel() { machine.cancel(); sync() }
+    fun frame() {
+        now = monoMillis()
+        val before = machine.state
+        machine.tick(now)
+        if (machine.state != before) sync()
+    }
+
+    private fun finishSolve(ms: Long, penalty: Penalty) {
+        val session = derived.session ?: return
+        val solve = Solve(randomId(), session.id, session.event, ms, penalty, scramble, "", epochMillis())
+        val before = derived.eventStats
+        val priorResults = repo.solves().filter { it.event == session.event }.map { it.result }
+        repo.addSolve(solve)
+        lastSolveId = solve.id
+        newScramble()
+        scope.launch {
+            val after = withContext(Dispatchers.Default) { StatSummary.of(priorResults + solve.result) }
+            // Celebrate only beating a real previous best, and skip mo3 (too frequent to be special).
+            val pbs = newPersonalBests(before, after).filter { it.previous != null && it.kind != StatKind.MO3 }
+            lastPbs = pbs
+            if (pbs.isNotEmpty()) celebrate(pbs)
+            else if (solve.result == DNF && sound) host.playChime(Chime.DNF)
+        }
+    }
+
+    private fun celebrate(pbs: List<PersonalBest>) {
+        val top = pbs.maxBy { it.kind.n }
+        val title = if (top.kind == StatKind.SINGLE) "NEW PB!" else "NEW ${top.kind.label.uppercase()} PB!"
+        val detail = pbs.joinToString("   ") { "${it.kind.label} ${formatTime(it.value, round = it.kind != StatKind.SINGLE)}" }
+        party = Party(title, detail)
+        if (sound) host.playChime(if (top.kind == StatKind.SINGLE) Chime.PB else Chime.AVERAGE_PB)
+    }
+
+    // ---- smart-cube replay ----
+
+    /** Play back a solve's recorded moves (csTimer `R@0 U'@120 ...`) at real speed. */
+    fun startReplay(solve: Solve) {
+        val moves = solve.moves ?: return
+        replayJob?.cancel()
+        replayJob = scope.launch {
+            val puzzle = Puzzles.cube(3)
+            val timed: List<Pair<Turn, Long>> = withContext(Dispatchers.Default) {
+                moves.split(' ').filter { '@' in it }.mapNotNull { tok ->
+                    val (mv, t) = tok.split('@', limit = 2)
+                    runCatching { puzzle.parse(mv).single() to t.toLong() }.getOrNull()
+                }
+            }
+            var st = puzzle.solved().apply(solve.scramble)
+            replay = Replay(solve.id, st, null, 0, timed.size, 0, playing = true)
+            val start = monoMillis()
+            for ((k, pair) in timed.withIndex()) {
+                val (turn, at) = pair
+                while (monoMillis() - start < at) { replay = replay?.copy(elapsedMs = monoMillis() - start); delay(16) }
+                val next = timed.getOrNull(k + 1)?.second ?: (at + 200)
+                val dur = (next - at).coerceIn(30, 110)
+                val t0 = monoMillis()
+                while (true) {
+                    val f = ((monoMillis() - t0).toFloat() / dur).coerceAtMost(1f)
+                    replay = replay?.copy(anim = TurnAnim(turn, f), elapsedMs = monoMillis() - start)
+                    if (f >= 1f) break
+                    delay(16)
+                }
+                st = st.apply(turn)
+                replay = replay?.copy(state = st, anim = null, index = k + 1)
+            }
+            replay = replay?.copy(playing = false, endedSolved = st.isSolved, elapsedMs = timed.lastOrNull()?.second ?: 0)
+        }
+    }
+
+    fun stopReplay() { replayJob?.cancel(); replay = null }
+
+    // ---- solve edits ----
+
+    fun setPenalty(id: String, p: Penalty) = repo.setPenalty(id, p)
+    fun deleteSolve(id: String) { repo.deleteSolve(id); if (selectedSolveId == id) selectedSolveId = null }
+    fun lastSolve(): Solve? = derived.sessionSolves.lastOrNull()
+
+    // ---- prefs ----
+
+    fun changeInspection(on: Boolean) { inspection = on; machine.inspection = on; repo.setPref("inspection", on) }
+    fun changeSound(on: Boolean) { sound = on; repo.setPref("sound", on) }
+    fun changeReducedMotion(on: Boolean) { reducedMotion = on; repo.setPref("reducedMotion", on) }
+    fun setTheme(m: ThemeMode) { themeMode = m; repo.setPref("theme", m.name) }
+    fun testChime() = host.playChime(Chime.PB)
+    fun testParty() = celebrate(listOf(PersonalBest(StatKind.SINGLE, 9_990, 10_420)))
+
+    // ---- imports ----
+
+    fun importCsTimer() = scope.launch {
+        val path = host.pickFile("Import csTimer export", listOf("txt", "json")) ?: return@launch
+        runImport("csTimer: $path") { Importer(repo).csTimer(host.readFile(path).decodeToString()) }
+    }
+
+    fun importLetterPairGym() = scope.launch {
+        val path = host.pickFile("Import Letter Pair Gym export", listOf("zip", "json")) ?: return@launch
+        runImport("Letter Pair Gym: $path") {
+            val (text, files) = host.readImport(path, "backup.json")
+            Importer(repo).letterPairGym(text, files)
+        }
+    }
+
+    private suspend fun runImport(what: String, block: suspend () -> Importer.Summary) {
+        importLog = importLog + "» importing $what"
+        try {
+            val s = withContext(Dispatchers.Default) { block() }
+            importLog = importLog + s.lines.map { "  ✓ $it" } + s.warnings.map { "  ! $it" }
+        } catch (e: Exception) {
+            importLog = importLog + "  ✗ failed: ${e.message}"
+        }
+    }
+
+    // ---- letter pairs ----
+
+    fun setPrimaryWord(pair: String, word: String) = repo.setPrimaryWord(pair, word.trim(), epochMillis())
+    fun setPairNote(pair: String, note: String) = repo.setPairNote(pair, note.ifBlank { null })
+    fun removeWord(pair: String, word: String) = repo.setWordInSet(pair, word, false)
+    fun addWord(pair: String, word: String) { if (word.isNotBlank()) repo.setWordInSet(pair, word.trim(), true) }
+    fun setPairImageFromFile(pair: String) = scope.launch {
+        val path = host.pickFile("Image for $pair", listOf("jpg", "jpeg", "png", "webp", "gif")) ?: return@launch
+        val bytes = host.readFile(path)
+        repo.setPairImage(pair, repo.store.blobs.put(bytes, path.substringAfterLast('.', "jpg")))
+    }
+    fun blob(name: String): ByteArray? = repo.store.blobs.get(name)
+}
diff --git a/ui/src/commonMain/kotlin/coffee/liz/rookery/ui/OtherScreens.kt b/ui/src/commonMain/kotlin/coffee/liz/rookery/ui/OtherScreens.kt
new file mode 100644
index 0000000..b861331
--- /dev/null
+++ b/ui/src/commonMain/kotlin/coffee/liz/rookery/ui/OtherScreens.kt
@@ -0,0 +1,112 @@
+package coffee.liz.rookery.ui
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.layout.widthIn
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+import kotlinx.coroutines.launch
+
+@Composable
+fun ImportScreen(m: AppModel) {
+    Column(Modifier.fillMaxSize().padding(8.dp).verticalScroll(rememberScrollState()), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+        GroupBox("Import", Modifier.widthIn(max = 720.dp)) {
+            Label("Imports are safe to repeat: anything already here is skipped.", color = Rk.c.inkDim)
+            Spacer(Modifier.height(8.dp))
+            Row(verticalAlignment = Alignment.CenterVertically) {
+                RetroButton("csTimer export…", { m.importCsTimer() })
+                Spacer(Modifier.width(8.dp))
+                Label("the .txt from csTimer's Export → \"Export to file\"", color = Rk.c.inkDim)
+            }
+            Spacer(Modifier.height(6.dp))
+            Row(verticalAlignment = Alignment.CenterVertically) {
+                RetroButton("Letter Pair Gym export…", { m.importLetterPairGym() })
+                Spacer(Modifier.width(8.dp))
+                Label("the .zip (words, notes, images, history, stats)", color = Rk.c.inkDim)
+            }
+        }
+        if (m.importLog.isNotEmpty()) GroupBox("Log", Modifier.widthIn(max = 720.dp)) {
+            Column(Modifier.fillMaxWidth().background(Rk.c.field).bevel(Rk.c, sunken = true).padding(8.dp)) {
+                for (line in m.importLog) Label(
+                    line, style = Rk.t.mono.copy(fontSize = Rk.t.mono.fontSize * 0.9f),
+                    color = when { line.trimStart().startsWith("✗") -> Rk.c.bad; line.trimStart().startsWith("!") -> Rk.c.gold; else -> Rk.c.ink },
+                )
+            }
+        }
+    }
+}
+
+@Composable
+fun SettingsScreen(m: AppModel) {
+    val scope = rememberCoroutineScope()
+    var syncPath by remember { mutableStateOf(m.host.syncFolder) }
+    var moved by remember { mutableStateOf(false) }
+    Column(Modifier.fillMaxSize().padding(8.dp).verticalScroll(rememberScrollState()), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+        GroupBox("Timer", Modifier.widthIn(max = 720.dp)) {
+            Checkbox("WCA inspection (15s, +2 after 15s, DNF after 17s)", m.inspection, m::changeInspection)
+            Checkbox("Sounds (PB chime, DNF blip)", m.sound, m::changeSound)
+            Row(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
+                RetroButton("Play PB chime", { m.testChime() })
+                RetroButton("Throw a test party", { m.testParty() })
+            }
+        }
+        GroupBox("Look", Modifier.widthIn(max = 720.dp)) {
+            Row(horizontalArrangement = Arrangement.spacedBy(6.dp), verticalAlignment = Alignment.CenterVertically) {
+                Label("Theme:", style = Rk.t.label)
+                for (t in ThemeMode.entries) RetroButton(t.name.lowercase(), { m.setTheme(t) }, selected = m.themeMode == t)
+            }
+            Checkbox("Reduce motion (no confetti, still penguins)", m.reducedMotion, m::changeReducedMotion)
+        }
+        GroupBox("Sync", Modifier.widthIn(max = 720.dp)) {
+            Label(
+                "Everything lives in this folder as per-device append-only logs. Point it at a Syncthing (or Drive, Dropbox, …) " +
+                    "folder and every device merges automatically. Each device only writes its own files, so syncing never conflicts.",
+                color = Rk.c.inkDim,
+            )
+            Spacer(Modifier.height(6.dp))
+            Row(verticalAlignment = Alignment.CenterVertically) {
+                RetroField(syncPath, { syncPath = it }, Modifier.weight(1f), description = "sync folder")
+                Spacer(Modifier.width(4.dp))
+                RetroButton("Browse…", { scope.launch { m.host.pickFolder("Sync folder")?.let { syncPath = it } } })
+                Spacer(Modifier.width(4.dp))
+                RetroButton("Apply", { m.host.setSyncFolder(syncPath); moved = true }, enabled = syncPath != m.host.syncFolder)
+            }
+            if (moved) Label("Saved. Restart Rookery to switch folders.", color = Rk.c.gold)
+            Label("This device: ${m.host.deviceId}", color = Rk.c.inkDim, style = Rk.t.label)
+        }
+        GroupBox("Smart cubes", Modifier.widthIn(max = 720.dp)) {
+            val devices = m.repo.devices()
+            if (devices.isEmpty()) Label("None yet. Import from csTimer, or pair one (coming in the smart-cube phase).", color = Rk.c.inkDim)
+            else {
+                Row { HeaderCell("name", 2f); HeaderCell("MAC", 2f); HeaderCell("protocol", 1f) }
+                for ((i, d) in devices.withIndex()) Row(Modifier.background(if (i % 2 == 1) Rk.c.zebra else Color.Transparent)) {
+                    Cell(d.name, 2f, style = Rk.t.body); Cell(d.mac, 2f); Cell(d.protocol, 1f)
+                }
+            }
+        }
+        GroupBox("Blindfolded", Modifier.widthIn(max = 720.dp)) {
+            Label("Orientation: yellow top, orange front · Speffz lettering", style = Rk.t.body)
+            Label("Corners: Old Pochmann, buffer UBL (A), target RDF (P)", style = Rk.t.body)
+            Label("Edges: buffer UR (B), targets UL (D, T-perm) · UB (A, Ja) · UF (C, Jb) · parity: R-perm", style = Rk.t.body)
+            Label("Editable when the BLD trainers land.", color = Rk.c.inkDim, style = Rk.t.label)
+        }
+    }
+}
diff --git a/ui/src/commonMain/kotlin/coffee/liz/rookery/ui/PairsScreen.kt b/ui/src/commonMain/kotlin/coffee/liz/rookery/ui/PairsScreen.kt
new file mode 100644
index 0000000..8bcd47b
--- /dev/null
+++ b/ui/src/commonMain/kotlin/coffee/liz/rookery/ui/PairsScreen.kt
@@ -0,0 +1,180 @@
+package coffee.liz.rookery.ui
+
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.horizontalScroll
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.text.BasicText
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.ImageBitmap
+import androidx.compose.ui.graphics.lerp
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import coffee.liz.rookery.model.LetterPair
+import org.jetbrains.compose.resources.decodeToImageBitmap
+
+const val LETTERS = "ABCDEFGHIJKLMNOPQRSTUVWX"
+
+@Composable
+fun PairsScreen(m: AppModel) {
+    var query by remember { mutableStateOf("") }
+    var selected by remember { mutableStateOf<String?>(null) }
+    val focus = remember { FocusRequester() }
+    LaunchedEffect(Unit) { focus.requestFocus() }
+    val glance = query.uppercase().filter { it in LETTERS }.take(2)
+    val shown = if (glance.length == 2) glance else selected
+
+    Row(Modifier.fillMaxSize().padding(8.dp), horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+        Column(Modifier.weight(1f).fillMaxHeight(), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+            GroupBox("Glance", Modifier.fillMaxWidth()) {
+                Row(verticalAlignment = Alignment.CenterVertically) {
+                    RetroField(
+                        query, { query = it.take(2) }, Modifier.width(120.dp).focusRequester(focus), placeholder = "AB",
+                        style = Rk.t.mono.copy(fontSize = 34.sp), description = "type a letter pair",
+                    )
+                    Spacer(Modifier.width(12.dp))
+                    val n = m.derived.pairs.values.count { it.primary != null }
+                    Label("Type two letters to look up a pair. $n of ${LETTERS.length * (LETTERS.length - 1)} pairs have words.", color = Rk.c.inkDim)
+                }
+            }
+            PairGrid(m.derived.pairs, shown) { selected = it; query = "" }
+        }
+        Column(Modifier.width(380.dp).fillMaxHeight()) {
+            if (shown != null) PairCard(m, shown, m.derived.pairs[shown])
+            else GroupBox("Pair", Modifier.fillMaxWidth()) { Label("Pick a cell, or type a pair.", color = Rk.c.inkDim) }
+        }
+    }
+}
+
+@Composable
+private fun PairGrid(pairs: Map<String, LetterPair>, selected: String?, onPick: (String) -> Unit) {
+    val p = Rk.c
+    val cellW = 74.dp
+    val cellH = 24.dp
+    Panel(Modifier.fillMaxSize(), padding = androidx.compose.foundation.layout.PaddingValues(2.dp)) {
+        Row(Modifier.padding(4.dp), verticalAlignment = Alignment.CenterVertically) {
+            Label("heat = recent misses", style = Rk.t.label, color = p.inkDim)
+            for (d in listOf(0.0, 0.33, 0.66, 1.0)) Box(Modifier.padding(start = 4.dp).size(14.dp).background(heat(p, d)).outline(p.bevelLo))
+        }
+        Box(Modifier.fillMaxSize().background(p.field).bevel(p, sunken = true).verticalScroll(rememberScrollState()).horizontalScroll(rememberScrollState())) {
+            Column {
+                Row {
+                    Box(Modifier.size(28.dp, cellH).background(p.panel).bevel(p))
+                    for (b in LETTERS) Box(Modifier.size(cellW, cellH).background(p.panel).bevel(p), Alignment.Center) {
+                        BasicText("$b", style = Rk.t.heading.copy(color = p.ink))
+                    }
+                }
+                for (a in LETTERS) Row {
+                    Box(Modifier.size(28.dp, cellH).background(p.panel).bevel(p), Alignment.Center) { BasicText("$a", style = Rk.t.heading.copy(color = p.ink)) }
+                    for (b in LETTERS) {
+                        val key = "$a$b"
+                        val lp = pairs[key]
+                        val sel = key == selected
+                        val bg = when {
+                            a == b -> p.panel
+                            sel -> p.select
+                            lp?.difficulty != null -> heat(p, lp.difficulty!!)
+                            else -> Color.Transparent
+                        }
+                        Box(
+                            Modifier.size(cellW, cellH).background(bg).outline(p.zebra)
+                                .then(if (a != b) Modifier.clickable { onPick(key) } else Modifier)
+                                .semantics { contentDescription = "$key ${lp?.primary ?: "no word"}" }
+                                .padding(horizontal = 3.dp),
+                            Alignment.CenterStart,
+                        ) {
+                            if (a != b) BasicText(
+                                lp?.primary ?: "·", maxLines = 1, overflow = TextOverflow.Ellipsis,
+                                style = Rk.t.body.copy(fontSize = 11.sp, color = if (sel) p.selectInk else if (lp?.primary == null) p.inkDim else p.ink),
+                            )
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+private fun heat(p: Palette, d: Double): Color {
+    val cold = if (p.dark) Color(0xFF15303F) else Color(0xFFDDEFF8)
+    val hot = if (p.dark) Color(0xFF6B2020) else Color(0xFFF4B4AE)
+    return lerp(cold, hot, d.toFloat().coerceIn(0f, 1f))
+}
+
+@Composable
+private fun PairCard(m: AppModel, pair: String, lp: LetterPair?) {
+    var word by remember(pair, lp?.primary) { mutableStateOf(lp?.primary.orEmpty()) }
+    var note by remember(pair, lp?.note) { mutableStateOf(lp?.note.orEmpty()) }
+    var alt by remember(pair) { mutableStateOf("") }
+    val image: ImageBitmap? = remember(lp?.image) {
+        lp?.image?.let { name -> runCatching { m.blob(name)?.decodeToImageBitmap() }.getOrNull() }
+    }
+    Panel(Modifier.fillMaxSize()) {
+        TitleBar(pair)
+        Spacer(Modifier.height(8.dp))
+        Box(Modifier.fillMaxWidth().height(240.dp).background(Rk.c.field).bevel(Rk.c, sunken = true), Alignment.Center) {
+            if (image != null) Image(image, lp?.primary ?: pair, Modifier.fillMaxSize().padding(4.dp), contentScale = ContentScale.Fit)
+            else Label("no image", color = Rk.c.inkDim, style = Rk.t.label)
+        }
+        Spacer(Modifier.height(6.dp))
+        BasicText(lp?.primary ?: "—", Modifier.fillMaxWidth(), style = Rk.t.mono.copy(fontSize = 44.sp, color = Rk.c.ink, textAlign = TextAlign.Center))
+        lp?.note?.let { Label(it, Modifier.fillMaxWidth(), color = Rk.c.inkDim) }
+        Hr()
+        Column(Modifier.verticalScroll(rememberScrollState()), verticalArrangement = Arrangement.spacedBy(6.dp)) {
+            Label("Main word", style = Rk.t.label)
+            Row(verticalAlignment = Alignment.CenterVertically) {
+                RetroField(word, { word = it }, Modifier.weight(1f), onSubmit = { m.setPrimaryWord(pair, word) }, description = "main word for $pair")
+                Spacer(Modifier.width(4.dp))
+                RetroButton("Save", { m.setPrimaryWord(pair, word) })
+            }
+            Label("Note", style = Rk.t.label)
+            Row(verticalAlignment = Alignment.CenterVertically) {
+                RetroField(note, { note = it }, Modifier.weight(1f), onSubmit = { m.setPairNote(pair, note) }, description = "note for $pair")
+                Spacer(Modifier.width(4.dp))
+                RetroButton("Save", { m.setPairNote(pair, note) })
+            }
+            Label("Other words", style = Rk.t.label)
+            for (w in lp?.words.orEmpty().filter { it != lp?.primary }.sorted()) Row(verticalAlignment = Alignment.CenterVertically) {
+                Label(w, Modifier.weight(1f))
+                RetroButton("Use", { m.setPrimaryWord(pair, w) }, description = "make $w the main word")
+                Spacer(Modifier.width(4.dp))
+                RetroButton("✕", { m.removeWord(pair, w) }, description = "remove $w")
+            }
+            Row(verticalAlignment = Alignment.CenterVertically) {
+                RetroField(alt, { alt = it }, Modifier.weight(1f), placeholder = "add a word…", onSubmit = { m.addWord(pair, alt); alt = "" })
+                Spacer(Modifier.width(4.dp))
+                RetroButton("Add", { m.addWord(pair, alt); alt = "" })
+            }
+            RetroButton("Image from file…", { m.setPairImageFromFile(pair) })
+        }
+    }
+}
diff --git a/ui/src/commonMain/kotlin/coffee/liz/rookery/ui/Penguin.kt b/ui/src/commonMain/kotlin/coffee/liz/rookery/ui/Penguin.kt
new file mode 100644
index 0000000..4da7994
--- /dev/null
+++ b/ui/src/commonMain/kotlin/coffee/liz/rookery/ui/Penguin.kt
@@ -0,0 +1,176 @@
+package coffee.liz.rookery.ui
+
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.text.BasicText
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableLongStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.withFrameMillis
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.FilterQuality
+import androidx.compose.ui.graphics.ImageBitmap
+import androidx.compose.ui.graphics.drawscope.DrawScope
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.IntOffset
+import androidx.compose.ui.unit.IntSize
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import coffee.liz.rookery.ui.res.Res
+import coffee.liz.rookery.ui.res.penguin_sheet
+import kotlinx.coroutines.delay
+import org.jetbrains.compose.resources.imageResource
+import kotlin.random.Random
+
+/**
+ * The penguin from liz.coffee: a 8x4 sheet of 32px frames in the oneko.js layout.
+ * Each animation is a list of (col, row) cells.
+ */
+enum class PenguinAnim(vararg cells: Pair<Int, Int>) {
+    IDLE(3 to 3), ALERT(7 to 3), PECK(5 to 0, 6 to 0, 7 to 0), TIRED(3 to 2), SLEEP(2 to 0, 2 to 1),
+    N(1 to 2, 1 to 3), NE(0 to 2, 0 to 3), E(3 to 0, 3 to 1), SE(5 to 1, 5 to 2),
+    S(6 to 3, 7 to 2), SW(5 to 3, 6 to 1), W(4 to 2, 4 to 3), NW(1 to 0, 1 to 1),
+    WALL_N(0 to 0, 0 to 1);
+
+    val frames: List<Pair<Int, Int>> = cells.toList()
+}
+
+const val SPRITE = 32
+
+@Composable
+fun penguinSheet(): ImageBitmap = imageResource(Res.drawable.penguin_sheet)
+
+fun DrawScope.drawPenguin(sheet: ImageBitmap, cell: Pair<Int, Int>, at: Offset, scale: Float, alpha: Float = 1f) {
+    drawImage(
+        sheet,
+        srcOffset = IntOffset(cell.first * SPRITE, cell.second * SPRITE),
+        srcSize = IntSize(SPRITE, SPRITE),
+        dstOffset = IntOffset(at.x.toInt(), at.y.toInt()),
+        dstSize = IntSize((SPRITE * scale).toInt(), (SPRITE * scale).toInt()),
+        alpha = alpha,
+        filterQuality = FilterQuality.None,
+    )
+}
+
+/** A single animated penguin. Static first frame when [reducedMotion]. */
+@Composable
+fun Penguin(anim: PenguinAnim, size: Dp = 64.dp, reducedMotion: Boolean = false, modifier: Modifier = Modifier, frameMs: Long = 220) {
+    val sheet = penguinSheet()
+    var frame by remember(anim) { mutableIntStateOf(0) }
+    LaunchedEffect(anim, reducedMotion) {
+        if (reducedMotion || anim.frames.size == 1) return@LaunchedEffect
+        while (true) { delay(frameMs); frame++ }
+    }
+    Canvas(modifier.size(size).semantics { contentDescription = "penguin, ${anim.name.lowercase()}" }) {
+        drawPenguin(sheet, anim.frames[frame % anim.frames.size], Offset.Zero, this.size.width / SPRITE)
+    }
+}
+
+/** What the mascot is up to, driven by the timer. */
+enum class Mood { IDLE, WATCHING, READY, SOLVING, HAPPY, SAD, SLEEPY }
+
+/** The mascot wanders along a strip, reacting to [mood]. */
+@Composable
+fun MascotStrip(mood: Mood, reducedMotion: Boolean, modifier: Modifier = Modifier, scale: Float = 2f) {
+    val sheet = penguinSheet()
+    BoxWithConstraints(modifier) {
+        val widthPx = constraints.maxWidth.toFloat()
+        var x by remember { mutableStateOf(40f) }
+        var target by remember { mutableStateOf(40f) }
+        var tick by remember { mutableLongStateOf(0) }
+        LaunchedEffect(mood, reducedMotion, widthPx) {
+            var last = 0L
+            while (true) {
+                withFrameMillis { t ->
+                    if (t - last > 120) { tick++; last = t }
+                    val spriteW = SPRITE * scale
+                    val maxX = (widthPx - spriteW).coerceAtLeast(0f)
+                    when (mood) {
+                        Mood.IDLE -> {
+                            if (!reducedMotion && kotlin.math.abs(target - x) < 2f && Random.nextInt(400) == 0) target = Random.nextFloat() * maxX
+                            if (!reducedMotion) x += (target - x).coerceIn(-1.6f, 1.6f)
+                        }
+                        Mood.HAPPY -> if (!reducedMotion) { target = (x + 3f).let { if (it > maxX) 0f else it }; x = target }
+                        else -> target = x
+                    }
+                    x = x.coerceIn(0f, maxX)
+                }
+            }
+        }
+        val anim = when (mood) {
+            Mood.IDLE -> if (kotlin.math.abs(target - x) >= 2f) (if (target > x) PenguinAnim.E else PenguinAnim.W) else PenguinAnim.IDLE
+            Mood.WATCHING -> PenguinAnim.S
+            Mood.READY -> PenguinAnim.ALERT
+            Mood.SOLVING -> PenguinAnim.N
+            Mood.HAPPY -> PenguinAnim.E
+            Mood.SAD -> PenguinAnim.PECK
+            Mood.SLEEPY -> PenguinAnim.SLEEP
+        }
+        val slow = if (anim == PenguinAnim.SLEEP) 6 else 2
+        Canvas(Modifier.fillMaxSize().semantics { contentDescription = "penguin mascot, ${mood.name.lowercase()}" }) {
+            val f = if (reducedMotion) 0 else ((tick / slow) % anim.frames.size).toInt()
+            drawPenguin(sheet, anim.frames[f], Offset(x, size.height - SPRITE * scale), scale)
+        }
+    }
+}
+
+/** Full-screen PB celebration: penguins rain down with pixel confetti and a blinking banner. */
+@Composable
+fun PbParty(title: String, detail: String, reducedMotion: Boolean, onDone: () -> Unit) {
+    val sheet = penguinSheet()
+    val p = Rk.c
+    class Bit(var x: Float, var y: Float, val vx: Float, val vy: Float, val penguin: Boolean, val color: Color, val anim: PenguinAnim, val size: Float)
+    val palette = listOf(Color(0xFFFFD54F), Color(0xFF7CC4FF), Color(0xFFFF8A80), Color(0xFF8CFF9E), Color(0xFFE1BEE7), Color.White)
+    val bits = remember {
+        List(70) { i ->
+            val penguin = i % 4 == 0
+            Bit(Random.nextFloat(), 0.1f - Random.nextFloat() * 0.8f, (Random.nextFloat() - 0.5f) * 0.0004f, 0.00025f + Random.nextFloat() * 0.0005f,
+                penguin, palette.random(), listOf(PenguinAnim.S, PenguinAnim.ALERT, PenguinAnim.SE, PenguinAnim.SW).random(), if (penguin) 2f else 6f + Random.nextInt(6))
+        }
+    }
+    var t by remember { mutableLongStateOf(0) }
+    LaunchedEffect(Unit) {
+        val start = withFrameMillis { it }
+        while (true) {
+            val now = withFrameMillis { it }
+            t = now - start
+            if (t > 4200) { onDone(); break }
+        }
+    }
+    Box(Modifier.fillMaxSize().semantics { contentDescription = "$title $detail" }) {
+        if (!reducedMotion) Canvas(Modifier.fillMaxSize()) {
+            for (b in bits) {
+                val x = (b.x + b.vx * t) * size.width
+                val y = (b.y + b.vy * t) * size.height
+                if (b.penguin) {
+                    drawPenguin(sheet, b.anim.frames[((t / 200) % b.anim.frames.size).toInt()], Offset(x, y), b.size)
+                } else {
+                    drawRect(b.color, Offset(x, y), Size(b.size, b.size))
+                }
+            }
+        }
+        val blinkOn = reducedMotion || (t / 300) % 2 == 0L
+        Box(Modifier.align(Alignment.Center).background(p.titleA).bevel(p).padding(horizontal = 28.dp, vertical = 16.dp), contentAlignment = Alignment.Center) {
+            androidx.compose.foundation.layout.Column(horizontalAlignment = Alignment.CenterHorizontally) {
+                BasicText("★ $title ★", style = Rk.t.heading.copy(fontSize = 28.sp, color = if (blinkOn) p.gold else p.titleInk))
+                BasicText(detail, Modifier.padding(top = 6.dp), style = Rk.t.mono.copy(fontSize = 30.sp, color = p.titleInk))
+            }
+        }
+    }
+}
diff --git a/ui/src/commonMain/kotlin/coffee/liz/rookery/ui/PuzzleView.kt b/ui/src/commonMain/kotlin/coffee/liz/rookery/ui/PuzzleView.kt
new file mode 100644
index 0000000..41ea00f
--- /dev/null
+++ b/ui/src/commonMain/kotlin/coffee/liz/rookery/ui/PuzzleView.kt
@@ -0,0 +1,124 @@
+package coffee.liz.rookery.ui
+
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.gestures.detectDragGestures
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Path
+import androidx.compose.ui.graphics.drawscope.DrawScope
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import coffee.liz.rookery.puzzle.Polygon
+import coffee.liz.rookery.puzzle.PuzzleState
+import coffee.liz.rookery.puzzle.Turn
+import coffee.liz.rookery.puzzle.V3
+import kotlin.math.PI
+import kotlin.math.cos
+import kotlin.math.min
+import kotlin.math.sin
+
+/** A turn in flight: draw [turn]'s layers rotated [progress] (0..1) of the way. */
+data class TurnAnim(val turn: Turn, val progress: Float)
+
+/** Camera angles in degrees; hoisted so callers can reset or remember them. */
+class Camera(yaw: Float = -32f, pitch: Float = 28f) {
+    var yaw by mutableFloatStateOf(yaw)
+    var pitch by mutableFloatStateOf(pitch)
+}
+
+/**
+ * Flat-shaded 3D puzzle, drawn with the painter's algorithm on a Canvas: each sticker is a black
+ * "plastic" tile with an inset coloured sticker, lit by a soft key light. Drag to orbit.
+ */
+@Composable
+fun PuzzleView(
+    state: PuzzleState,
+    faceColors: List<Color>,
+    modifier: Modifier = Modifier,
+    camera: Camera = remember { Camera() },
+    anim: TurnAnim? = null,
+    description: String = "3D puzzle view",
+) {
+    val puzzle = state.puzzle
+    val body = Color(0xFF14181C)
+    Canvas(
+        modifier
+            .pointerInput(camera) {
+                detectDragGestures { change, drag ->
+                    change.consume()
+                    camera.yaw += drag.x * 0.45f
+                    camera.pitch = (camera.pitch + drag.y * 0.45f).coerceIn(-89f, 89f)
+                }
+            }
+            .semantics { contentDescription = description },
+    ) {
+        val yaw = camera.yaw * PI / 180
+        val pitch = camera.pitch * PI / 180
+        // world → view: yaw about y, then pitch about x
+        fun view(p: V3): V3 {
+            val x1 = p.x * cos(yaw) + p.z * sin(yaw)
+            val z1 = -p.x * sin(yaw) + p.z * cos(yaw)
+            val y2 = p.y * cos(pitch) - z1 * sin(pitch)
+            val z2 = p.y * sin(pitch) + z1 * cos(pitch)
+            return V3(x1, y2, z2)
+        }
+        val radius = puzzle.stickers.maxOf { s -> s.points.maxOf { it.length } }
+        val dist = radius * 4.5
+        val scale = min(size.width, size.height) / 2f / radius.toFloat() * 0.80f
+        val cx = size.width / 2; val cy = size.height / 2
+        fun project(p: V3): Offset {
+            val k = (dist / (dist - p.z)).toFloat()
+            return Offset(cx + p.x.toFloat() * scale * k, cy - p.y.toFloat() * scale * k)
+        }
+        val light = V3(-0.4, 0.75, 0.55).unit()
+
+        val turning = anim?.let { a ->
+            val axis = puzzle.axes[a.turn.axis]
+            val angle = -2 * PI * a.turn.amount / axis.order * a.progress
+            Triple(a.turn, axis.normal, angle)
+        }
+
+        class Drawn(val tile: Polygon, val color: Color, val depth: Double, val shade: Float)
+        val drawn = ArrayList<Drawn>(puzzle.stickers.size)
+        for ((i, s) in puzzle.stickers.withIndex()) {
+            var poly = s
+            if (turning != null && puzzle.slabOf(turning.first.axis, i) in turning.first.layers) {
+                poly = poly.map { it.rotate(turning.second, turning.third) }
+            }
+            val v = poly.map(::view)
+            val toCam = V3(0.0, 0.0, dist) - v.centroid
+            val n = v.normal
+            if ((n dot toCam) <= 0) continue // back face
+            val lambert = maxOf(0.0, n dot light).toFloat()
+            drawn += Drawn(v, faceColors[state.colors[i] % faceColors.size], v.centroid.z, 0.62f + 0.38f * lambert)
+        }
+        drawn.sortBy { it.depth }
+        for (d in drawn) {
+            fill(d.tile.points.map(::project), body)
+            val sticker = d.tile.inset(0.86).points.map(::project)
+            fill(sticker, d.color.shaded(d.shade))
+            // a thin highlight on the sticker's upper edge for a slightly glossy, skeuomorphic feel
+            drawPath(path(sticker), Color.White.copy(alpha = 0.10f * d.shade), style = Stroke(1f))
+        }
+    }
+}
+
+private fun path(pts: List<Offset>) = Path().apply {
+    moveTo(pts[0].x, pts[0].y)
+    for (k in 1 until pts.size) lineTo(pts[k].x, pts[k].y)
+    close()
+}
+
+private fun DrawScope.fill(pts: List<Offset>, c: Color) = drawPath(path(pts), c)
+
+private fun Color.shaded(k: Float) = Color(red * k, green * k, blue * k, alpha)
+
+fun rgb(hex: Long) = Color(0xFF000000 or hex)
diff --git a/ui/src/commonMain/kotlin/coffee/liz/rookery/ui/Retro.kt b/ui/src/commonMain/kotlin/coffee/liz/rookery/ui/Retro.kt
new file mode 100644
index 0000000..2fe6be5
--- /dev/null
+++ b/ui/src/commonMain/kotlin/coffee/liz/rookery/ui/Retro.kt
@@ -0,0 +1,225 @@
+package coffee.liz.rookery.ui
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.focusable
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.interaction.collectIsFocusedAsState
+import androidx.compose.foundation.interaction.collectIsPressedAsState
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ColumnScope
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.RowScope
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.text.BasicText
+import androidx.compose.foundation.text.BasicTextField
+import androidx.compose.foundation.text.KeyboardActions
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.drawBehind
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.PathEffect
+import androidx.compose.ui.graphics.SolidColor
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.selected
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.input.ImeAction
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+
+/** Classic two-tone 3D border: light top-left, dark bottom-right (swapped when [sunken]). */
+fun Modifier.bevel(p: Palette, sunken: Boolean = false, width: Dp = 2.dp): Modifier = drawBehind {
+    val w = width.toPx()
+    val hi = if (sunken) p.bevelLo else p.bevelHi
+    val lo = if (sunken) p.bevelHi else p.bevelLo
+    val outer = if (sunken) p.bevelDark else p.bevelDark
+    // outer frame
+    drawRect(if (sunken) outer else hi, Offset.Zero, androidx.compose.ui.geometry.Size(size.width, w / 2))
+    drawRect(if (sunken) outer else hi, Offset.Zero, androidx.compose.ui.geometry.Size(w / 2, size.height))
+    drawRect(if (sunken) hi else outer, Offset(0f, size.height - w / 2), androidx.compose.ui.geometry.Size(size.width, w / 2))
+    drawRect(if (sunken) hi else outer, Offset(size.width - w / 2, 0f), androidx.compose.ui.geometry.Size(w / 2, size.height))
+    // inner frame
+    drawRect(if (sunken) lo else hi, Offset(w / 2, w / 2), androidx.compose.ui.geometry.Size(size.width - w, w / 2))
+    drawRect(if (sunken) lo else hi, Offset(w / 2, w / 2), androidx.compose.ui.geometry.Size(w / 2, size.height - w))
+    drawRect(if (sunken) hi else lo, Offset(w / 2, size.height - w), androidx.compose.ui.geometry.Size(size.width - w, w / 2))
+    drawRect(if (sunken) hi else lo, Offset(size.width - w, w / 2), androidx.compose.ui.geometry.Size(w / 2, size.height - w))
+}
+
+/** Win98-style dotted focus ring, so keyboard users always see where they are. */
+fun Modifier.focusRing(focused: Boolean, color: Color): Modifier = if (!focused) this else drawBehind {
+    drawRect(color, topLeft = Offset(4f, 4f), size = androidx.compose.ui.geometry.Size(size.width - 8f, size.height - 8f),
+        style = Stroke(1.5f, pathEffect = PathEffect.dashPathEffect(floatArrayOf(2f, 2f))))
+}
+
+@Composable
+fun Panel(modifier: Modifier = Modifier, sunken: Boolean = false, padding: PaddingValues = PaddingValues(8.dp), content: @Composable ColumnScope.() -> Unit) {
+    val p = Rk.c
+    Column(modifier.background(if (sunken) p.field else p.panel).bevel(p, sunken).padding(padding), content = content)
+}
+
+/** A titled group box, like a <fieldset>. */
+@Composable
+fun GroupBox(title: String, modifier: Modifier = Modifier, content: @Composable ColumnScope.() -> Unit) {
+    Panel(modifier) {
+        BasicText(title.uppercase(), style = Rk.t.heading.copy(color = Rk.c.ink))
+        Box(Modifier.height(6.dp))
+        content()
+    }
+}
+
+@Composable
+fun TitleBar(text: String, modifier: Modifier = Modifier, trailing: @Composable RowScope.() -> Unit = {}) {
+    val p = Rk.c
+    Row(
+        modifier.fillMaxWidth().background(Brush.horizontalGradient(listOf(p.titleA, p.titleB))).padding(horizontal = 8.dp, vertical = 4.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        BasicText(text, Modifier.weight(1f), style = Rk.t.heading.copy(color = p.titleInk))
+        trailing()
+    }
+}
+
+@Composable
+fun RetroButton(
+    text: String,
+    onClick: () -> Unit,
+    modifier: Modifier = Modifier,
+    enabled: Boolean = true,
+    selected: Boolean = false,
+    description: String? = null,
+    style: TextStyle? = null,
+) {
+    val p = Rk.c
+    val src = remember { MutableInteractionSource() }
+    val pressed by src.collectIsPressedAsState()
+    val focused by src.collectIsFocusedAsState()
+    val sunken = pressed || selected
+    Box(
+        modifier
+            .background(if (selected) p.zebra else p.panel)
+            .bevel(p, sunken)
+            .focusRing(focused, p.ink)
+            .clickable(src, indication = null, enabled = enabled, role = Role.Button, onClick = onClick)
+            .semantics { if (description != null) contentDescription = description; this.selected = selected }
+            .padding(horizontal = 12.dp, vertical = 6.dp)
+            .padding(start = if (sunken) 1.dp else 0.dp, top = if (sunken) 1.dp else 0.dp),
+        contentAlignment = Alignment.Center,
+    ) {
+        BasicText(text, style = (style ?: Rk.t.label).copy(color = if (enabled) p.ink else p.inkDim), maxLines = 1)
+    }
+}
+
+/** Tab strip; the selected tab merges into the panel below it. */
+@Composable
+fun <T> Tabs(items: List<T>, selected: T, label: (T) -> String, onSelect: (T) -> Unit, modifier: Modifier = Modifier) {
+    val p = Rk.c
+    Row(modifier.padding(start = 6.dp, top = 6.dp), horizontalArrangement = Arrangement.spacedBy(2.dp), verticalAlignment = Alignment.Bottom) {
+        for (item in items) {
+            val sel = item == selected
+            val src = remember { MutableInteractionSource() }
+            val focused by src.collectIsFocusedAsState()
+            Box(
+                Modifier
+                    .background(if (sel) p.panel else p.zebra)
+                    .bevel(p)
+                    .focusRing(focused, p.ink)
+                    .clickable(src, null, role = Role.Tab) { onSelect(item) }
+                    .semantics { this.selected = sel }
+                    .padding(horizontal = 14.dp, vertical = if (sel) 8.dp else 5.dp),
+            ) { BasicText(label(item), style = Rk.t.label.copy(color = p.ink)) }
+        }
+    }
+}
+
+@Composable
+fun Label(text: String, modifier: Modifier = Modifier, color: Color? = null, style: TextStyle? = null, maxLines: Int = Int.MAX_VALUE) {
+    BasicText(text, modifier, style = (style ?: Rk.t.body).copy(color = color ?: Rk.c.ink), maxLines = maxLines, overflow = TextOverflow.Ellipsis)
+}
+
+@Composable
+fun RetroField(
+    value: String,
+    onValueChange: (String) -> Unit,
+    modifier: Modifier = Modifier,
+    placeholder: String = "",
+    style: TextStyle? = null,
+    singleLine: Boolean = true,
+    onSubmit: (() -> Unit)? = null,
+    description: String? = null,
+) {
+    val p = Rk.c
+    val st = (style ?: Rk.t.body).copy(color = p.ink)
+    BasicTextField(
+        value, onValueChange,
+        modifier.background(p.field).bevel(p, sunken = true).padding(horizontal = 8.dp, vertical = 6.dp)
+            .semantics { if (description != null) contentDescription = description },
+        textStyle = st, singleLine = singleLine, cursorBrush = SolidColor(p.ink),
+        keyboardOptions = KeyboardOptions(imeAction = if (onSubmit != null) ImeAction.Done else ImeAction.Default),
+        keyboardActions = KeyboardActions(onDone = { onSubmit?.invoke() }),
+        decorationBox = { inner ->
+            Box {
+                if (value.isEmpty()) BasicText(placeholder, style = st.copy(color = p.inkDim))
+                inner()
+            }
+        },
+    )
+}
+
+@Composable
+fun Checkbox(label: String, checked: Boolean, onChange: (Boolean) -> Unit, modifier: Modifier = Modifier) {
+    val p = Rk.c
+    val src = remember { MutableInteractionSource() }
+    val focused by src.collectIsFocusedAsState()
+    Row(
+        modifier.focusRing(focused, p.ink).clickable(src, null, role = Role.Checkbox) { onChange(!checked) }.padding(6.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Box(Modifier.size(16.dp).background(p.field).bevel(p, sunken = true), contentAlignment = Alignment.Center) {
+            if (checked) BasicText("✓", style = Rk.t.body.copy(color = p.ink))
+        }
+        Box(Modifier.width(8.dp))
+        Label(label)
+    }
+}
+
+/** Header cell for <table>-style grids. */
+@Composable
+fun RowScope.HeaderCell(text: String, weight: Float, modifier: Modifier = Modifier) {
+    Box(modifier.weight(weight).background(Rk.c.panel).bevel(Rk.c).padding(horizontal = 6.dp, vertical = 3.dp)) {
+        BasicText(text, style = Rk.t.label.copy(color = Rk.c.ink), maxLines = 1)
+    }
+}
+
+@Composable
+fun RowScope.Cell(text: String, weight: Float, color: Color? = null, style: TextStyle? = null, modifier: Modifier = Modifier) {
+    Box(modifier.weight(weight).padding(horizontal = 6.dp, vertical = 3.dp)) {
+        BasicText(text, style = (style ?: Rk.t.mono.copy(fontSize = Rk.t.mono.fontSize)).copy(color = color ?: Rk.c.ink), maxLines = 1, overflow = TextOverflow.Ellipsis)
+    }
+}
+
+@Composable
+fun Hr(modifier: Modifier = Modifier) {
+    Box(modifier.fillMaxWidth().padding(vertical = 6.dp).height(2.dp).bevel(Rk.c, sunken = true, width = 2.dp))
+}
+
+fun Modifier.outline(c: Color) = border(1.dp, c)
+
+fun Modifier.focusableIf(b: Boolean) = if (b) focusable() else this
diff --git a/ui/src/commonMain/kotlin/coffee/liz/rookery/ui/Theme.kt b/ui/src/commonMain/kotlin/coffee/liz/rookery/ui/Theme.kt
new file mode 100644
index 0000000..d2ef012
--- /dev/null
+++ b/ui/src/commonMain/kotlin/coffee/liz/rookery/ui/Theme.kt
@@ -0,0 +1,75 @@
+package coffee.liz.rookery.ui
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.Immutable
+import androidx.compose.runtime.staticCompositionLocalOf
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.unit.sp
+import coffee.liz.rookery.ui.res.Res
+import coffee.liz.rookery.ui.res.silkscreen
+import coffee.liz.rookery.ui.res.silkscreen_bold
+import coffee.liz.rookery.ui.res.vt323
+import org.jetbrains.compose.resources.Font
+import androidx.compose.ui.text.font.FontWeight
+
+/** Colour tokens. Two themes: "ice floe" (light) and "polar night" (dark). */
+@Immutable
+data class Palette(
+    val bg: Color, val panel: Color, val bevelHi: Color, val bevelLo: Color, val bevelDark: Color,
+    val ink: Color, val inkDim: Color, val field: Color, val zebra: Color,
+    val titleA: Color, val titleB: Color, val titleInk: Color,
+    val select: Color, val selectInk: Color,
+    val good: Color, val bad: Color, val gold: Color, val lcd: Color, val lcdInk: Color,
+    /** Sticker colours U R F D L B for scramble previews in this orientation. */
+    val dark: Boolean,
+) {
+    companion object {
+        val IceFloe = Palette(
+            bg = Color(0xFFDFE7EC), panel = Color(0xFFC9D3DA), bevelHi = Color(0xFFFFFFFF), bevelLo = Color(0xFF6B7A86), bevelDark = Color(0xFF26313A),
+            ink = Color(0xFF101820), inkDim = Color(0xFF45525D), field = Color(0xFFFFFFFF), zebra = Color(0xFFE8EEF2),
+            titleA = Color(0xFF123A57), titleB = Color(0xFF3F88C5), titleInk = Color.White,
+            select = Color(0xFF1F5F8F), selectInk = Color.White,
+            good = Color(0xFF256B2A), bad = Color(0xFFB3261E), gold = Color(0xFFB07A00),
+            lcd = Color(0xFF9DB89A), lcdInk = Color(0xFF14220F), dark = false,
+        )
+        val PolarNight = Palette(
+            bg = Color(0xFF0C1216), panel = Color(0xFF17212A), bevelHi = Color(0xFF34465A), bevelLo = Color(0xFF070A0D), bevelDark = Color(0xFF000000),
+            ink = Color(0xFFE3ECF1), inkDim = Color(0xFF9AACB8), field = Color(0xFF0A0F13), zebra = Color(0xFF131C23),
+            titleA = Color(0xFF0B2233), titleB = Color(0xFF2B6C9E), titleInk = Color(0xFFE3ECF1),
+            select = Color(0xFF2B6C9E), selectInk = Color.White,
+            good = Color(0xFF7AD67F), bad = Color(0xFFFF8A80), gold = Color(0xFFFFD54F),
+            lcd = Color(0xFF0F1E12), lcdInk = Color(0xFF8CFF9E), dark = true,
+        )
+    }
+}
+
+@Immutable
+data class Type(val pixel: FontFamily, val pixelBold: FontFamily, val lcd: FontFamily) {
+    val heading get() = TextStyle(fontFamily = pixelBold, fontSize = 14.sp, letterSpacing = 0.5.sp)
+    val label get() = TextStyle(fontFamily = pixel, fontSize = 12.sp)
+    val body get() = TextStyle(fontSize = 14.sp)
+    val mono get() = TextStyle(fontFamily = lcd, fontSize = 20.sp)
+}
+
+val LocalPalette = staticCompositionLocalOf { Palette.IceFloe }
+val LocalType = staticCompositionLocalOf<Type> { error("no type") }
+
+object Rk {
+    val c: Palette @Composable get() = LocalPalette.current
+    val t: Type @Composable get() = LocalType.current
+}
+
+@Composable
+fun RookeryTheme(dark: Boolean, content: @Composable () -> Unit) {
+    val type = Type(
+        pixel = FontFamily(Font(Res.font.silkscreen)),
+        pixelBold = FontFamily(Font(Res.font.silkscreen_bold, FontWeight.Bold)),
+        lcd = FontFamily(Font(Res.font.vt323)),
+    )
+    CompositionLocalProvider(LocalPalette provides if (dark) Palette.PolarNight else Palette.IceFloe, LocalType provides type) {
+        content()
+    }
+}
diff --git a/ui/src/commonMain/kotlin/coffee/liz/rookery/ui/TimerScreen.kt b/ui/src/commonMain/kotlin/coffee/liz/rookery/ui/TimerScreen.kt
new file mode 100644
index 0000000..e475436
--- /dev/null
+++ b/ui/src/commonMain/kotlin/coffee/liz/rookery/ui/TimerScreen.kt
@@ -0,0 +1,323 @@
+package coffee.liz.rookery.ui
+
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.gestures.awaitEachGesture
+import androidx.compose.foundation.gestures.awaitFirstDown
+import androidx.compose.foundation.gestures.waitForUpOrCancellation
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.foundation.text.BasicText
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.withFrameMillis
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.semantics.LiveRegionMode
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.liveRegion
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import coffee.liz.rookery.model.DNF
+import coffee.liz.rookery.model.Event
+import coffee.liz.rookery.model.Penalty
+import coffee.liz.rookery.model.Puzzle
+import coffee.liz.rookery.puzzle.Puzzles
+import coffee.liz.rookery.model.formatSolve
+import coffee.liz.rookery.model.formatTime
+import coffee.liz.rookery.stats.Averages
+import coffee.liz.rookery.stats.StatKind
+import coffee.liz.rookery.timer.TimerMachine
+import coffee.liz.rookery.timer.TimerMachine.State
+import org.jetbrains.compose.resources.ExperimentalResourceApi
+import org.jetbrains.compose.resources.decodeToSvgPainter
+
+@Composable
+fun TimerScreen(m: AppModel) {
+    // drive the clock while something is ticking
+    val ticking = m.timer !is State.Idle && m.timer !is State.Stopped
+    LaunchedEffect(ticking) { while (ticking) withFrameMillis { m.frame() } }
+    LaunchedEffect(Unit) { while (true) { kotlinx.coroutines.delay(1000); m.frame() } }
+
+    Row(Modifier.fillMaxSize().padding(8.dp), horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+        Column(Modifier.width(290.dp).fillMaxHeight(), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+            SessionBox(m)
+            SolveTable(m, Modifier.weight(1f))
+        }
+        Column(Modifier.weight(1f).fillMaxHeight(), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+            ScrambleBox(m)
+            TimerDisplay(m, Modifier.weight(1f))
+            LastSolveBar(m)
+        }
+        Column(Modifier.width(290.dp).fillMaxHeight().verticalScroll(rememberScrollState()), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+            StatsBox(m)
+            PreviewBox(m)
+            SelectedSolveBox(m)
+        }
+    }
+}
+
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+private fun SessionBox(m: AppModel) {
+    var choosing by remember { mutableStateOf(false) }
+    GroupBox("Session") {
+        Column(Modifier.heightIn(max = 160.dp)) {
+            LazyColumn {
+                itemsIndexed(m.derived.sessions) { i, s ->
+                    val sel = s.id == m.derived.session?.id
+                    Row(
+                        Modifier.fillMaxWidth().background(if (sel) Rk.c.select else if (i % 2 == 1) Rk.c.zebra else Color.Transparent)
+                            .clickable { m.selectSession(s.id) }.padding(horizontal = 6.dp, vertical = 3.dp),
+                    ) {
+                        Label(s.name, Modifier.weight(1f), color = if (sel) Rk.c.selectInk else null, maxLines = 1)
+                        Label(s.event.short, color = if (sel) Rk.c.selectInk else Rk.c.inkDim, style = Rk.t.label)
+                    }
+                }
+            }
+        }
+        Spacer(Modifier.height(6.dp))
+        RetroButton(if (choosing) "Cancel" else "New session…", { choosing = !choosing })
+        if (choosing) {
+            Spacer(Modifier.height(6.dp))
+            FlowRow(horizontalArrangement = Arrangement.spacedBy(4.dp), verticalArrangement = Arrangement.spacedBy(4.dp)) {
+                for (e in Event.entries) RetroButton(e.short, { m.createSession(e); choosing = false }, description = "New ${e.title} session")
+            }
+        }
+    }
+}
+
+@Composable
+private fun SolveTable(m: AppModel, modifier: Modifier) {
+    val solves = m.derived.sessionSolves
+    val results = remember(solves) { solves.map { it.result } }
+    val list = rememberLazyListState()
+    LaunchedEffect(solves.size) { if (solves.isNotEmpty()) list.scrollToItem(0) }
+    Panel(modifier.fillMaxWidth(), padding = androidx.compose.foundation.layout.PaddingValues(2.dp)) {
+        Row(Modifier.fillMaxWidth()) {
+            HeaderCell("#", 0.6f); HeaderCell("time", 1.4f); HeaderCell("ao5", 1.2f); HeaderCell("ao12", 1.2f)
+        }
+        Box(Modifier.fillMaxSize().background(Rk.c.field).bevel(Rk.c, sunken = true)) {
+            LazyColumn(state = list) {
+                val n = solves.size
+                itemsIndexed(solves.asReversed(), key = { _, s -> s.id }) { ri, s ->
+                    val i = n - 1 - ri
+                    val sel = s.id == m.selectedSolveId
+                    val ao5 = if (i >= 4) formatTime(Averages.average(results.subList(i - 4, i + 1)), true) else ""
+                    val ao12 = if (i >= 11) formatTime(Averages.average(results.subList(i - 11, i + 1)), true) else ""
+                    val ink = if (sel) Rk.c.selectInk else Rk.c.ink
+                    Row(
+                        Modifier.fillMaxWidth().background(if (sel) Rk.c.select else if (ri % 2 == 1) Rk.c.zebra else Color.Transparent)
+                            .clickable { m.selectedSolveId = if (sel) null else s.id }
+                            .semantics(mergeDescendants = true) { contentDescription = "solve ${i + 1}, ${formatSolve(s)}" },
+                    ) {
+                        Cell("${i + 1}", 0.6f, color = if (sel) ink else Rk.c.inkDim)
+                        Cell(if (s.penalty == Penalty.DNF) "DNF" else formatSolve(s), 1.4f, color = when { sel -> ink; s.penalty == Penalty.DNF -> Rk.c.bad; else -> ink })
+                        Cell(ao5, 1.2f, color = ink)
+                        Cell(ao12, 1.2f, color = ink)
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun ScrambleBox(m: AppModel) {
+    Panel(Modifier.fillMaxWidth()) {
+        Row(verticalAlignment = Alignment.CenterVertically) {
+            Label(m.event.title.uppercase(), Modifier.weight(1f), style = Rk.t.heading)
+            RetroButton("Next ▸", { m.newScramble() }, description = "next scramble")
+        }
+        Spacer(Modifier.height(6.dp))
+        val size = when { m.scramble.length > 300 -> 18.sp; m.scramble.length > 120 -> 22.sp; else -> 30.sp }
+        BasicText(
+            m.scramble, Modifier.fillMaxWidth().background(Rk.c.field).bevel(Rk.c, sunken = true).padding(10.dp)
+                .semantics { contentDescription = "scramble: ${m.scramble}" },
+            style = Rk.t.mono.copy(fontSize = size, color = Rk.c.ink, textAlign = TextAlign.Center, lineHeight = size * 1.15f),
+        )
+    }
+}
+
+@Composable
+private fun TimerDisplay(m: AppModel, modifier: Modifier) {
+    val p = Rk.c
+    val s = m.timer
+    val (text, color) = timerText(s, m.now, m.lastSolve()?.let { formatSolve(it) }, p)
+    val mood = when {
+        s is State.Running -> Mood.SOLVING
+        s is State.Ready -> Mood.READY
+        s is State.Inspecting || s is State.Holding -> Mood.WATCHING
+        s is State.Stopped && m.lastPbs.isNotEmpty() -> Mood.HAPPY
+        s is State.Stopped && s.penalty == Penalty.DNF -> Mood.SAD
+        m.now - m.lastActivity > 90_000 -> Mood.SLEEPY
+        else -> Mood.IDLE
+    }
+    Column(
+        modifier.fillMaxWidth().background(p.lcd).bevel(p, sunken = true)
+            .pointerInput(Unit) {
+                awaitEachGesture {
+                    awaitFirstDown(); m.press()
+                    waitForUpOrCancellation(); m.release()
+                }
+            },
+    ) {
+        Box(Modifier.weight(1f).fillMaxWidth(), contentAlignment = Alignment.Center) {
+            BasicText(
+                text,
+                Modifier.semantics { liveRegion = LiveRegionMode.Polite; contentDescription = "timer $text" },
+                style = Rk.t.mono.copy(fontSize = 150.sp, color = color, textAlign = TextAlign.Center),
+            )
+        }
+        BasicText(
+            hint(s, m.inspection), Modifier.fillMaxWidth().padding(4.dp),
+            style = Rk.t.label.copy(color = p.lcdInk.copy(alpha = 0.7f), textAlign = TextAlign.Center),
+        )
+        MascotStrip(mood, m.reducedMotion, Modifier.fillMaxWidth().height(72.dp))
+    }
+}
+
+private fun timerText(s: State, now: Long, last: String?, p: Palette): Pair<String, Color> = when (s) {
+    State.Idle -> (last ?: "0.00") to p.lcdInk
+    is State.Inspecting -> {
+        val left = 15 - (now - s.since) / 1000
+        (if (left > 0) "$left" else if (left > -2) "+2" else "DNF") to if (left <= 3) p.bad else p.lcdInk
+    }
+    is State.Holding -> (s.inspectingSince?.let { "${(15 - (now - it) / 1000).coerceAtLeast(0)}" } ?: "0.00") to p.bad
+    is State.Ready -> "0.00" to p.good
+    is State.Running -> formatTime(now - s.since).let { if (s.penalty == Penalty.PLUS2) "$it+" else it } to p.lcdInk
+    is State.Stopped -> when (s.penalty) {
+        Penalty.DNF -> "DNF"
+        Penalty.PLUS2 -> formatTime(s.ms + 2000) + "+"
+        Penalty.NONE -> formatTime(s.ms)
+    } to p.lcdInk
+}
+
+private fun hint(s: State, inspection: Boolean) = when (s) {
+    State.Idle, is State.Stopped -> if (inspection) "space / tap: start inspection" else "hold space / tap and hold: get ready"
+    is State.Inspecting -> "hold space to get ready"
+    is State.Holding -> "keep holding…"
+    is State.Ready -> "release to start!"
+    is State.Running -> "any key / tap to stop"
+}
+
+@Composable
+private fun LastSolveBar(m: AppModel) {
+    val last = m.lastSolve() ?: return
+    Row(horizontalArrangement = Arrangement.spacedBy(6.dp), verticalAlignment = Alignment.CenterVertically) {
+        Label("last solve:", style = Rk.t.label)
+        RetroButton("OK", { m.setPenalty(last.id, Penalty.NONE) }, selected = last.penalty == Penalty.NONE, description = "no penalty (ctrl+1)")
+        RetroButton("+2", { m.setPenalty(last.id, Penalty.PLUS2) }, selected = last.penalty == Penalty.PLUS2, description = "plus two (ctrl+2)")
+        RetroButton("DNF", { m.setPenalty(last.id, Penalty.DNF) }, selected = last.penalty == Penalty.DNF, description = "DNF (ctrl+3)")
+        RetroButton("Delete", { m.deleteSolve(last.id) }, description = "delete last solve")
+        Spacer(Modifier.weight(1f))
+        if (m.lastPbs.isNotEmpty()) Label("★ " + m.lastPbs.joinToString { it.kind.label } + " PB", color = Rk.c.gold, style = Rk.t.heading)
+    }
+}
+
+@Composable
+private fun StatsBox(m: AppModel) {
+    val ss = m.derived.sessionStats
+    val es = m.derived.eventStats
+    GroupBox("Stats") {
+        Row { HeaderCell("", 1f); HeaderCell("now", 1.2f); HeaderCell("best", 1.2f); HeaderCell("ever", 1.2f) }
+        for ((i, k) in listOf(StatKind.SINGLE, StatKind.MO3, StatKind.AO5, StatKind.AO12, StatKind.AO50, StatKind.AO100, StatKind.AO1000).withIndex()) {
+            val line = ss.line(k)
+            val life = es.line(k)
+            if (line == null && life == null) continue
+            val round = k != StatKind.SINGLE
+            Row(Modifier.background(if (i % 2 == 1) Rk.c.zebra else Rk.c.field)) {
+                Cell(k.label, 1f, style = Rk.t.label)
+                Cell(formatTime(line?.current, round), 1.2f)
+                Cell(formatTime(line?.best, round), 1.2f)
+                Cell(formatTime(life?.best, round), 1.2f, color = Rk.c.gold.takeIf { life?.best != null && life.best == line?.best && life.best != DNF })
+            }
+        }
+        Spacer(Modifier.height(4.dp))
+        Label("${ss.solved}/${ss.count} solved · mean ${formatTime(ss.mean, true)}", color = Rk.c.inkDim, style = Rk.t.label)
+    }
+}
+
+@OptIn(ExperimentalResourceApi::class)
+@Composable
+private fun PreviewBox(m: AppModel) {
+    m.replay?.let { ReplayBox(m, it); return }
+    val state = m.previewState
+    val svg = m.previewSvg
+    val density = LocalDensity.current
+    val painter = remember(svg, density) { svg?.let { runCatching { it.encodeToByteArray().decodeToSvgPainter(density) }.getOrNull() } }
+    GroupBox("Scramble preview") {
+        val colors = remember(m.event) { Puzzles.colors(m.event.puzzle).map(::rgb) }
+        if (state != null) PuzzleView(state, colors, Modifier.fillMaxWidth().height(200.dp), description = "3D scramble preview, drag to rotate")
+        // tnoodle's official 2D drawing: the reference for every event
+        if (painter != null) Image(painter, "scramble drawing for ${m.event.title}", Modifier.fillMaxWidth().height(if (state != null) 120.dp else 170.dp))
+    }
+}
+
+@Composable
+private fun ReplayBox(m: AppModel, r: Replay) {
+    val camera = remember(r.solveId) { Camera() }
+    GroupBox("Replay") {
+        PuzzleView(r.state, remember { Puzzles.colors(Puzzle.CUBE3).map(::rgb) }, Modifier.fillMaxWidth().height(240.dp), camera, r.anim, "solve replay, drag to rotate")
+        Label("move ${r.index}/${r.total} · ${formatTime(r.elapsedMs)}", style = Rk.t.mono)
+        when (r.endedSolved) {
+            true -> Label("✓ moves solve the scramble", color = Rk.c.good, style = Rk.t.label)
+            false -> Label("✗ cube not solved at the end", color = Rk.c.bad, style = Rk.t.label)
+            null -> {}
+        }
+        Spacer(Modifier.height(4.dp))
+        Row(horizontalArrangement = Arrangement.spacedBy(4.dp)) {
+            m.derived.sessionSolves.firstOrNull { it.id == r.solveId }?.let { s -> RetroButton("↺ Again", { m.startReplay(s) }) }
+            RetroButton("Close", { m.stopReplay() })
+        }
+    }
+}
+
+@Composable
+private fun SelectedSolveBox(m: AppModel) {
+    val s = m.derived.sessionSolves.firstOrNull { it.id == m.selectedSolveId } ?: return
+    GroupBox("Solve") {
+        Label(formatSolve(s), style = Rk.t.mono.copy(fontSize = 36.sp))
+        Label(s.scramble, style = Rk.t.mono.copy(fontSize = 16.sp), color = Rk.c.inkDim)
+        s.moves?.let { mv -> Label("smart-cube reconstruction · ${mv.split(' ').size} moves", style = Rk.t.label, color = Rk.c.inkDim) }
+        if (s.comment.isNotEmpty()) Label("“${s.comment}”")
+        if (s.moves != null && s.event.puzzle == Puzzle.CUBE3) {
+            Spacer(Modifier.height(4.dp))
+            RetroButton("▶ Replay in 3D", { m.startReplay(s) })
+        }
+        Spacer(Modifier.height(6.dp))
+        Row(horizontalArrangement = Arrangement.spacedBy(4.dp)) {
+            RetroButton("OK", { m.setPenalty(s.id, Penalty.NONE) }, selected = s.penalty == Penalty.NONE)
+            RetroButton("+2", { m.setPenalty(s.id, Penalty.PLUS2) }, selected = s.penalty == Penalty.PLUS2)
+            RetroButton("DNF", { m.setPenalty(s.id, Penalty.DNF) }, selected = s.penalty == Penalty.DNF)
+            RetroButton("Delete", { m.deleteSolve(s.id) })
+        }
+    }
+}