diff --git a/docs/UPGRADE-PLAN.md b/docs/UPGRADE-PLAN.md
index 629078f5..66100825 100644
--- a/docs/UPGRADE-PLAN.md
+++ b/docs/UPGRADE-PLAN.md
@@ -538,9 +538,54 @@ All decomposition outputs are authored in TypeScript from the start (`engine/*.t
 
    The probe was then REPLACED by a permanent guard instead of being deleted: `src/toolchain/typescriptSupport.ts` + its test. Reason: with the probe gone there is no `.ts` under `include`, so the gate would be green over ZERO TypeScript — indistinguishable from green over working TypeScript until someone tries to convert something. The guard is read by both pipelines (tsc proves the checker sees `.ts`; Jest proves Babel strips it), and it was verified to FAIL when `@babel/preset-typescript` is removed. It sits outside `src/core`/`src/library`, so it is outside `collectCoverageFrom` and nothing imports it — confirmed absent from `dist/index.js`. **Delete it once real converted modules cover the same ground (E1 onwards).**
 
-#### E1 — Utils and contract first (highest leverage)
+#### E1 — Utils and contract first (highest leverage) — 🔶 **FIRST HALF SHIPPED 2026-09-17**
 
-- `src/core/utils` (~36 files, pure, React-free) — mechanical conversion, immediately types everything downstream.
+- ~~`src/core/utils` (~36 files, pure, React-free) — mechanical conversion~~ ✅ **DONE 2026-09-17. 20 files, not ~36** — the count predates H1 and the earlier deletions; it was 20 files / 4142 lines with 26 test files over them. All 20 are now `.ts`, strict, with the suite and the coverage thresholds unchanged.
+
+  **MEASURED, which is what the go/no-go below needs and never had:**
+
+  | wave | files | lines | agent-minutes | `any` |
+  |---|---|---|---|---|
+  | 1 — leaves | 8 | 1072 → 1160 | 127 | 20 |
+  | 2 — `_envs`, `components`, `string` | 3 | 719 → 806 | 53 | 0 |
+  | 3 — `array`, `definitions` | 2 | 650 → 745 | 57 | 2 |
+  | 4 — `function`, `number`, `object`, `translations` | 4 | 1407 → 1523 | 87 | 2 |
+  | 5 — `storage`, `utility` + barrel | 3 | 294 → 344 | 40 | 0 |
+  | **total** | **20** | **4142 → 4578 (+10.5%)** | **364** | **23** |
+
+  **Cost does not track size, it tracks how polymorphic the signature is.** `lodash-lite` (552 lines,
+  a lodash reimplementation) took 55 minutes and carries **17 of the 23 `any`** on its own. `string`
+  (663 lines — longer) took 35 minutes and needed none. Across the package there are 23 `any` against
+  **199 `unknown`**, so the conversion narrowed honestly rather than reaching for the escape hatch.
+  "mechanical conversion" was right for about 17 of the 20 files and wrong for the polymorphic ones.
+
+  **Three infrastructure holes, none of them predicted here, all of the same shape — a gate keyed on
+  file extension stops watching whatever the migration moves, and says nothing:**
+
+  1. 38 intra-`utils` imports carried an explicit `.js` extension, which Jest and webpack resolve
+     literally, so every rename broke resolution. `tsc` cannot warn: `checkJs` is off. It fails at
+     test and build time instead. A second round found the same thing in `jest.doMock`/`require`
+     forms and inside `__tests__`, which the first sweep's `from '…'` pattern had missed.
+  2. `lint:js` was extended to `.ts` in E0 — and immediately caught that
+     `eslint-config-react-app` turns `no-use-before-define` OFF for `.js` but ON for `.ts`, so a
+     pre-existing pattern started failing the zero-warning gate purely because of an extension.
+  3. `collectCoverageFrom` listed `{js,jsx}`, so converted files dropped out of coverage entirely.
+     Because `utils` is among the best-covered code here, losing it pushed the GLOBAL numbers DOWN
+     and the thresholds red — while plain `jest` stayed green. Three per-file thresholds also still
+     named `./src/core/utils/*.js`, which jest reports as "coverage data not found", not as an error.
+
+  **Behaviour was held still, deliberately, and the record of where that cost something is in the
+  commits:** `definitions.localise` gained an unused optional parameter so an existing recursive call
+  would typecheck without editing that line; `utility` uses a non-null assertion on
+  `Active.passwordCheck` because it being undefined and throwing IS the backend behaviour;
+  `function.debounce` keeps `arguments` rather than rest parameters, at the cost of two inert
+  `as unknown as` casts, so the emitted JavaScript stays byte-identical.
+
+  **One real contract question surfaced and is left for whoever converts the caller:**
+  `src/core/components/renders.js:139` calls `round(value, decimals)` where `value` can be a numeric
+  string from `data.json`, while the six rounding helpers are typed `number` per their JSDoc. Nothing
+  breaks today because `renders.js` is unchecked JavaScript. Widening the helpers or casting at the
+  call site is a decision about what the contract is.
 - **Contract types for meta/data**, authored together with the JSON Schema (§9.4). Pick one source of truth (types→schema or schema→types) and add a round-trip check so they cannot diverge.
 
 #### E2 — Components and modules (rides other workstreams)
@@ -571,7 +616,22 @@ All decomposition outputs are authored in TypeScript from the start (`engine/*.t
 
 #### Governance — go/no-go after E1
 
-E0/E1 plus the contract types are committed scope. Before green-lighting the long E2/E3 tail (~250 files riding two large workstreams), hold an explicit go/no-go on measured E1 conversion velocity. Until E4 lands, hedge the hand-written `dist/index.d.ts` cheaply with type-level tests (`tsd`/`expectTypeOf`) asserting the public types against the example metas.
+E0/E1 plus the contract types are committed scope. Before green-lighting the long E2/E3 tail (~250 files riding two large workstreams), hold an explicit go/no-go on measured E1 conversion velocity.
+
+**The measurement now exists (2026-09-17), so the gate can actually be held.** From the E1 table
+above: **364 agent-minutes for 4142 lines**, ≈11 lines/minute, over 20 files. Extrapolating to the
+~155 `.js`/`.jsx` files still in `src` is NOT a straight multiplication, and the E1 data is the
+reason to say so rather than a caveat added for safety:
+
+  - `utils` is **pure and React-free**. E2's components carry JSX, hooks, prop types and the DOM
+    boundary, none of which this measurement covers.
+  - Cost concentrated in polymorphic signatures, and E2 has its own version of that problem in the
+    engine's open prop spreads.
+  - Three of E1's five blockers were INFRASTRUCTURE, not typing, and those are now paid for once —
+    the next waves should not re-pay them.
+
+So the honest reading is: the mechanical half is cheap and now has a number; the go/no-go should
+still turn on a **pilot of two or three real components**, not on extrapolating utils. Until E4 lands, hedge the hand-written `dist/index.d.ts` cheaply with type-level tests (`tsd`/`expectTypeOf`) asserting the public types against the example metas.
 
 #### Definition of done
 
@@ -1330,7 +1390,7 @@ Every check this plan depends on, in one place. ✅ = already verified during th
 - ☐ E4: golden `dist/index.d.ts` diff reviewed — only intended changes
 - ☐ E5: semantic `type` proxy recreated as TS aliases (same vocabulary) before the engine converts
 - ☐ E5: `rg "prop-types" src` returns nothing → `prop-types` removed from `dependencies`, bundle-size delta recorded
-- ☐ Go/no-go on the E2/E3 tail held after E1 (measured conversion velocity); hand-written d.ts hedged with type-level tests until E4
+- ☐ Go/no-go on the E2/E3 tail held after E1 — **the velocity measurement now exists** (§9.6-E1: 20 files, 4142 lines, 364 agent-minutes, 23 `any` against 199 `unknown`); the DECISION is still outstanding, and §9.6's governance note argues it should turn on a 2–3 component pilot rather than on extrapolating pure utils; hand-written d.ts hedged with type-level tests until E4
 
 ### Phase 6 — engine decomposition (§9.3)
 
diff --git a/jest.config.js b/jest.config.js
index 0bc0deb1..fa40e581 100644
--- a/jest.config.js
+++ b/jest.config.js
@@ -21,11 +21,16 @@ module.exports = {
         '<rootDir>/\\.[^/]+/worktrees/',
         '<rootDir>/src/style/__tests__/setup.js',
     ],
+    // `ts,tsx` added at §9.6-E1: converting a file to TypeScript must not remove it from the coverage
+    // denominator. It silently did — the whole of src/core/utils dropped out of measurement on
+    // conversion, and because those files are among the best covered in the repo, losing them pushed
+    // the GLOBAL numbers DOWN and the thresholds red. A coverage config that tracks file extensions
+    // has to be widened in step with any migration, or the gate quietly stops watching what it moved.
     collectCoverageFrom: [
-        '<rootDir>/src/core/**/*.{js,jsx}',
-        '<rootDir>/src/library/**/*.{js,jsx}',
+        '<rootDir>/src/core/**/*.{js,jsx,ts,tsx}',
+        '<rootDir>/src/library/**/*.{js,jsx,ts,tsx}',
         '!<rootDir>/src/**/__tests__/**',
-        '!<rootDir>/src/**/*.test.{js,jsx}',
+        '!<rootDir>/src/**/*.test.{js,jsx,ts,tsx}',
         '!<rootDir>/src/**/__mocks__/**',
     ],
     coverageThreshold: {
@@ -242,13 +247,13 @@ module.exports = {
             functions: 100,
             lines: 100,
         },
-        './src/core/utils/storage.js': {
+        './src/core/utils/storage.ts': {
             statements: 100,
             branches: 100,
             functions: 100,
             lines: 100,
         },
-        './src/core/utils/function.js': {
+        './src/core/utils/function.ts': {
             statements: 100,
             branches: 96,
             functions: 77,
@@ -296,7 +301,7 @@ module.exports = {
             functions: 100,
             lines: 100,
         },
-        './src/core/utils/definitions.js': {
+        './src/core/utils/definitions.ts': {
             statements: 100,
             branches: 100,
             functions: 100,
diff --git a/src/core/components/__tests__/Table.test.js b/src/core/components/__tests__/Table.test.js
index 52648abc..eec06ce8 100644
--- a/src/core/components/__tests__/Table.test.js
+++ b/src/core/components/__tests__/Table.test.js
@@ -209,7 +209,7 @@ describe('Table', () => {
             // a re-introduction would otherwise only surface in a generated-page diff.
             // Matched as a module reference, not as the bare string: the file's own header
             // explains what it replaced, and a substring check would fail on the prose.
-            const source = require('fs').readFileSync(require.resolve('../Table.js'), 'utf8')
+            const source = require('fs').readFileSync(require.resolve('../Table'), 'utf8')
             expect(source).not.toMatch(/(?:from|require\(|import\(|jest\.mock\()\s*['"]semantic-ui-react/)
         })
 
diff --git a/src/core/utils/__tests__/utility.id-collisions-and-history.test.js b/src/core/utils/__tests__/utility.id-collisions-and-history.test.js
index 0bf03013..7b42d7e3 100644
--- a/src/core/utils/__tests__/utility.id-collisions-and-history.test.js
+++ b/src/core/utils/__tests__/utility.id-collisions-and-history.test.js
@@ -1,6 +1,6 @@
 describe('Id collision and history contracts', () => {
     afterEach(() => {
-        jest.dontMock('../string.js')
+        jest.dontMock('../string')
         jest.resetModules()
     })
 
@@ -8,14 +8,14 @@ describe('Id collision and history contracts', () => {
         jest.resetModules()
         const randomString = jest.fn()
         values.forEach(value => randomString.mockReturnValueOnce(value))
-        jest.doMock('../string.js', () => ({
-            ...jest.requireActual('../string.js'),
+        jest.doMock('../string', () => ({
+            ...jest.requireActual('../string'),
             randomString,
         }))
 
         let utility
         jest.isolateModules(() => {
-            utility = require('../utility.js')
+            utility = require('../utility')
         })
 
         return { ...utility, randomString }
diff --git a/src/core/utils/_envs.js b/src/core/utils/_envs.js
deleted file mode 100644
index 23e1f510..00000000
--- a/src/core/utils/_envs.js
+++ /dev/null
@@ -1,55 +0,0 @@
-import { LANGUAGE } from './constants.js'
-
-/**
- * Environment Variables
- * @note: for Next.js, explicitly set variable on initialisation like so:
- *   import config from 'next/config'
- *   import { ENV } from './'
- *
- *   Object.assign(ENV, config().publicRuntimeConfig)
- */
-export let ENV = (typeof process !== 'undefined' && process.env) || {}
-export const NODE_ENV = ENV.NODE_ENV // @Note: Next.js does not automatically add NODE_ENV, set inside next.config.js
-export const __PROD__ = NODE_ENV === 'production'
-export const __STAGE__ = NODE_ENV === 'stage'
-export const __TEST__ = NODE_ENV === 'test'
-export const __DEV__ = NODE_ENV === 'development'
-export const __CLIENT__ = typeof window !== 'undefined'
-export const __BACKEND__ = !__CLIENT__
-export const __IOS__ = false
-export const _INIT_ = __BACKEND__ && (__PROD__ || __STAGE__)
-export const _WORK_DIR_ = typeof process !== 'undefined' ? process.cwd() : '.' // relative to root `index.js`
-export const UNDEFINED = (Undefined => Undefined)()
-
-/* Globally Accessible Objects */
-export const Active = {
-  // will be overridden at runtime, used for avoiding circular import and env-dependent libraries
-  DEFAULT: {LANGUAGE: LANGUAGE.ENGLISH._},
-  LANG: LANGUAGE.ENGLISH, // currently used language
-  Storage: typeof localStorage !== 'undefined' ? localStorage : undefined, // LocalStorage for Node
-  WebSocket: typeof WebSocket !== 'undefined' ? WebSocket : undefined, // WebSocket for Node
-  history: {}, // Cross Platform route history object
-  iconClass: '', // CSS className for <Icon />
-  iconClassPrefix: 'icon-', // CSS className prefix for <Icon />
-  client: undefined, // Apollo client
-  log: undefined, // backend console logger
-  user: {}, // the current user, for quick access to user info, such as auth
-  usersById: {}, // for storing temporary info, like user.lastOnline
-  translate: (value) => value, // Global translate function
-
-  /**
-   * Password Strength Calculator
-   * @example: <script async src="/static/zxcvbn.js"/>
-   *    - Frontend uses async script in <head/> section to load static zxcvbn.js for faster page load.
-   *    - Backend should override this prop with `Active.passwordCheck = require('zxcvbn')`
-   * @returns {zxcvbn|(function(): {score: number})|*}
-   */
-  get passwordCheck () {
-    // When not loaded, skip password validation in frontend
-    if (typeof window !== 'undefined') return window.zxcvbn || (() => ({score: Infinity}))
-    return this.zxcvbn
-  },
-  set passwordCheck (zxcvbn) {
-    this.zxcvbn = zxcvbn
-  }
-}
diff --git a/src/core/utils/_envs.ts b/src/core/utils/_envs.ts
new file mode 100644
index 00000000..6c75a1c7
--- /dev/null
+++ b/src/core/utils/_envs.ts
@@ -0,0 +1,93 @@
+import { LANGUAGE } from './constants'
+
+/** One of the language definitions declared in `constants.ts` (e.g. `LANGUAGE.ENGLISH`) */
+export type Language = (typeof LANGUAGE)[keyof typeof LANGUAGE]
+
+/** The `_` code of a language definition (e.g. `'en'`, `'zh_CN'`) */
+export type LanguageCode = Language['_']
+
+/** Password strength calculator, compatible with the subset of `zxcvbn` that is actually used */
+export type PasswordCheck = (password?: string) => {score: number}
+
+/** Global translate function - strings are localised, everything else passes through unchanged */
+export type Translate = <T>(value: T) => T
+
+/**
+ * Shape of the globally accessible `Active` object.
+ * @note: every slot is a mutable runtime injection point, so the env-dependent ones are typed
+ *    `unknown` (narrow before use) and the index signature admits the extra props that platform
+ *    code attaches at runtime (`Field`, `renderField`, `UIRender`, `SERVICE`, `state`, ...).
+ */
+export interface ActiveEnv {
+  [key: string]: unknown
+
+  DEFAULT: {LANGUAGE: LanguageCode}
+  LANG: Language
+  Storage: unknown
+  WebSocket: unknown
+  history: unknown
+  iconClass: string
+  iconClassPrefix: string
+  client: unknown
+  log: unknown
+  user: Record<string, unknown>
+  usersById: Record<string, unknown>
+  translate: Translate
+  /** Storage slot behind the `passwordCheck` accessor pair */
+  zxcvbn?: PasswordCheck
+  passwordCheck: PasswordCheck | undefined
+}
+
+/**
+ * Environment Variables
+ * @note: for Next.js, explicitly set variable on initialisation like so:
+ *   import config from 'next/config'
+ *   import { ENV } from './'
+ *
+ *   Object.assign(ENV, config().publicRuntimeConfig)
+ */
+export let ENV: Record<string, string | undefined> = (typeof process !== 'undefined' && process.env) || {}
+export const NODE_ENV: string | undefined = ENV.NODE_ENV // @Note: Next.js does not automatically add NODE_ENV, set inside next.config.js
+export const __PROD__: boolean = NODE_ENV === 'production'
+export const __STAGE__: boolean = NODE_ENV === 'stage'
+export const __TEST__: boolean = NODE_ENV === 'test'
+export const __DEV__: boolean = NODE_ENV === 'development'
+export const __CLIENT__: boolean = typeof window !== 'undefined'
+export const __BACKEND__: boolean = !__CLIENT__
+export const __IOS__: boolean = false
+export const _INIT_: boolean = __BACKEND__ && (__PROD__ || __STAGE__)
+export const _WORK_DIR_: string = typeof process !== 'undefined' ? process.cwd() : '.' // relative to root `index.js`
+export const UNDEFINED: undefined = ((Undefined?: undefined) => Undefined)()
+
+/* Globally Accessible Objects */
+export const Active: ActiveEnv = {
+  // will be overridden at runtime, used for avoiding circular import and env-dependent libraries
+  DEFAULT: {LANGUAGE: LANGUAGE.ENGLISH._},
+  LANG: LANGUAGE.ENGLISH, // currently used language
+  Storage: typeof localStorage !== 'undefined' ? localStorage : undefined, // LocalStorage for Node
+  WebSocket: typeof WebSocket !== 'undefined' ? WebSocket : undefined, // WebSocket for Node
+  history: {}, // Cross Platform route history object
+  iconClass: '', // CSS className for <Icon />
+  iconClassPrefix: 'icon-', // CSS className prefix for <Icon />
+  client: undefined, // Apollo client
+  log: undefined, // backend console logger
+  user: {}, // the current user, for quick access to user info, such as auth
+  usersById: {}, // for storing temporary info, like user.lastOnline
+  translate: (value) => value, // Global translate function
+
+  /**
+   * Password Strength Calculator
+   * @example: <script async src="/static/zxcvbn.js"/>
+   *    - Frontend uses async script in <head/> section to load static zxcvbn.js for faster page load.
+   *    - Backend should override this prop with `Active.passwordCheck = require('zxcvbn')`
+   * @returns {zxcvbn|(function(): {score: number})|*}
+   */
+  get passwordCheck (): PasswordCheck | undefined {
+    // When not loaded, skip password validation in frontend
+    if (typeof window !== 'undefined') return (window as unknown as {zxcvbn?: PasswordCheck}).zxcvbn || (() => ({score: Infinity}))
+    return this.zxcvbn
+  },
+  set passwordCheck (zxcvbn: PasswordCheck | undefined) {
+    this.zxcvbn = zxcvbn
+  }
+}
diff --git a/src/core/utils/array.js b/src/core/utils/array.ts
similarity index 66%
rename from src/core/utils/array.js
rename to src/core/utils/array.ts
index 00c6771c..8c3e19be 100644
--- a/src/core/utils/array.js
+++ b/src/core/utils/array.ts
@@ -12,21 +12,51 @@ import {
   unionBy,
   unionWith,
   uniqWith,
-} from './lodash-lite.js'
-import { toLowerCaseAny } from './string.js'
+} from './lodash-lite'
+import { toLowerCaseAny } from './string'
 
 /**
  * ARRAY FUNCTIONS =============================================================
  * =============================================================================
  */
 
+/**
+ * @Note on the types (§9.6-E1): these helpers are deliberately polymorphic, exactly like the
+ * lodash-lite subset they build on. The types stay LOOSE on purpose — `unknown` for values that are
+ * only inspected, element generics where the runtime passes a value through, and no tightening of
+ * what any function accepts at runtime.
+ */
+
+/** Anything walked with a computed string key once the value is known to be object-like. */
+type Obj = Record<string, unknown>
+
+/**
+ * Anything `isEqualList` compares: it reads `.length` and enumerable index keys off both arguments,
+ * which is what an array, an array-like or a string gives it at runtime.
+ */
+type MaybeIndexed = { length?: unknown, [key: string]: unknown }
+
+/**
+ * A user supplied compare function, as taken by {@link by}.
+ * @Note: the parameters are `any` on purpose — `unknown` there would reject every caller that
+ *    annotates its own comparator, e.g. `by((a: Row, b: Row) => …)`.
+ */
+type CompareFn = (a: any, b: any) => number
+
+/**
+ * The shorthands {@link isInCollection} forwards to lodash-lite's `some()`: a predicate function or
+ * a source object to match (both are `object`), a property path, or any other primitive — the same
+ * surface `some()` accepts at runtime.
+ */
+type CollectionMatch = object | PropertyKey | boolean | bigint | null | undefined
+
 /**
  * Check if the data passed is an array and has values.
  *
  * @param {*} data - The variable to check
  * @return {boolean}
  */
-export function hasListValue (data) {
+export function hasListValue (data: unknown): boolean {
   return (isList(data) && data.length > 0)
 }
 
@@ -36,8 +66,8 @@ export function hasListValue (data) {
  * @param {*} data - The variable to check
  * @return {boolean}
  */
-export function isCollection (data) {
-  return (!!data && (data.constructor === Array || isPlainObject(data)))
+export function isCollection (data: unknown): boolean {
+  return (!!data && ((data as { constructor?: unknown }).constructor === Array || isPlainObject(data)))
 }
 
 /**
@@ -47,12 +77,12 @@ export function isCollection (data) {
  * @param {Array|*} b
  * @returns {Boolean} true - if all elements of `a` are equal to all elements of `b` using exact equality match
  */
-export function isEqualList (a, b) {
+export function isEqualList (a: unknown, b: unknown): boolean {
   if (a === b) return true
-  if (a && b && a.length !== b.length) return false
+  if (a && b && (a as MaybeIndexed).length !== (b as MaybeIndexed).length) return false
   if (!a || !b) return false
-  for (const i in a) {
-    if (a[i] !== b[i]) return false
+  for (const i in (a as MaybeIndexed)) {
+    if ((a as MaybeIndexed)[i] !== (b as MaybeIndexed)[i]) return false
   }
   return true
 }
@@ -63,8 +93,8 @@ export function isEqualList (a, b) {
  * @param {*} data - The variable to check
  * @return {boolean}
  */
-export function isList (data) {
-  return (!!data && data.constructor === Array)
+export function isList (data: unknown): data is unknown[] {
+  return (!!data && (data as { constructor?: unknown }).constructor === Array)
 }
 
 /**
@@ -74,7 +104,7 @@ export function isList (data) {
  * @param {*} value - needle
  * @return {boolean}
  */
-export function isInList (array, value) {
+export function isInList (array: readonly unknown[], value: unknown): boolean {
   return array.indexOf(value) >= 0
 }
 
@@ -84,7 +114,7 @@ export function isInList (array, value) {
  * @param {Array} array - the array to search for the values
  * @param {*} args - the values to search for
  */
-export function isInListAny (array, ...args) {
+export function isInListAny (array: readonly unknown[], ...args: unknown[]): boolean {
   for (const value of args) {
     if (array.indexOf(value) >= 0) {
       return true
@@ -100,7 +130,7 @@ export function isInListAny (array, ...args) {
  * @see {@link https://lodash.com/docs/4.17.2#some} for further information.
  * @return {Boolean} true - if element found in given collection with shallow include match
  */
-export function isInCollection (collection, element) {
+export function isInCollection (collection: unknown, element: CollectionMatch): boolean {
   return some(collection, element)
 }
 
@@ -111,9 +141,10 @@ export function isInCollection (collection, element) {
  * @param {*} [clean] - if truthy, remove falsey values: false, null, 0, "", undefined, and NaN
  * @return {Array}
  */
-export function toList (value, clean) { // eslint-disable-line no-shadow
+export function toList<T> (value: T | T[], clean?: unknown): T[]
+export function toList (value: unknown, clean?: unknown): unknown[] { // eslint-disable-line no-shadow
   if (!isList(value)) value = [value]
-  return clean ? value.filter(v => v) : value
+  return clean ? (value as unknown[]).filter(v => v) : (value as unknown[])
 }
 
 /**
@@ -128,10 +159,11 @@ export function toList (value, clean) { // eslint-disable-line no-shadow
  * @param {Number} [fallback] - default value to use when not a number encountered
  * @returns {Number} total - of all element values
  */
-export function toListValuesTotal (array = [], key = 'value', fallback = 0) {
+export function toListValuesTotal (array: ReadonlyArray<Obj> = [], key: string = 'value', fallback: number = 0): number {
   let sum = 0
   for (const obj of array) {
-    sum += obj[key] || fallback
+    // the cast mirrors the runtime: non-numeric and missing values fall back to `fallback`
+    sum += (obj[key] as number) || fallback
   }
   return sum
 }
@@ -147,7 +179,8 @@ export function toListValuesTotal (array = [], key = 'value', fallback = 0) {
  * @param {Array} array - the array to enforce unique values for
  * @return {Array}
  */
-export function toUniqueList (array) {
+export function toUniqueList<T> (array: T | T[]): T[]
+export function toUniqueList (array: unknown) {
   return uniqWith(toList(array), isEqual)
 }
 
@@ -157,7 +190,7 @@ export function toUniqueList (array) {
  * @param {Array} array - the array to enforce unique primitive values for
  * @return {Array} - new array
  */
-export function toUniqueListFast (array) {
+export function toUniqueListFast<T> (array: readonly T[]): T[] {
   return array.filter((value, index, self) => self.indexOf(value) === index)
 }
 
@@ -167,7 +200,7 @@ export function toUniqueListFast (array) {
  * @param {Array<*>} array - the array to enforce unique values for (can be mix of value types)
  * @return {Array<*>} list - new array containing only unique values, case insensitive
  */
-export function toUniqueListCaseInsensitive (array) {
+export function toUniqueListCaseInsensitive<T> (array: readonly T[]): T[] {
   const listLower = array.map(toLowerCaseAny)
   return array.filter((v, i) => listLower.indexOf(toLowerCaseAny(v)) === i)
 }
@@ -182,8 +215,8 @@ export function toUniqueListCaseInsensitive (array) {
  * @param {string} key - objects's key that needs to be unique
  * @returns {Array} list - of unique objects
  */
-export function toUniqueListByKey (newList, oldList, key) {
-  return unionBy(newList, oldList, key)
+export function toUniqueListByKey<T> (newList: readonly T[], oldList: readonly T[], key: string): T[] {
+  return unionBy(newList, oldList, key) as T[]
 }
 
 /**
@@ -193,7 +226,7 @@ export function toUniqueListByKey (newList, oldList, key) {
  * @param {*} value - to prepend to `array`
  * @param {number} [limit] - optionally trim array to this length
  */
-export function prependToList (array, value, limit) {
+export function prependToList<T> (array: readonly T[], value: T, limit?: number): T[] {
   const result = [value, ...array]
   if (limit && result.length > limit) result.length = limit
   return result
@@ -205,7 +238,7 @@ export function prependToList (array, value, limit) {
  * @param {Array} arrays - lists to combine (if not array given, it will be ignored without error)
  * @returns {Array} - merged list with unique values
  */
-export function mergeLists (...arrays) {
+export function mergeLists<T> (...arrays: Array<readonly T[] | null | undefined>): T[] {
   return union(...arrays)
 }
 
@@ -216,13 +249,13 @@ export function mergeLists (...arrays) {
  * @param {String|Number|Array} valueToRemove - to remove
  * @return {Array} - new array with value removed
  */
-export function removeFromList (listToKeep, valueToRemove) {
+export function removeFromList<T> (listToKeep: readonly T[], valueToRemove: T | readonly T[]): T[] {
   // Value is Array
   if (isList(valueToRemove)) return difference(listToKeep, valueToRemove)
 
   // Value is of primitive type
   const result = [...listToKeep]
-  const index = listToKeep.indexOf(valueToRemove)
+  const index = listToKeep.indexOf(valueToRemove as T)
   if (index > -1) result.splice(index, 1)
   return result
 }
@@ -233,7 +266,9 @@ export function removeFromList (listToKeep, valueToRemove) {
  * @param {Array|*} array - The array to query
  * @returns {*} - The first element of the array
  */
-export function firstListValue (array) {
+export function firstListValue<T> (array: readonly T[]): T
+export function firstListValue<T> (array: T): T
+export function firstListValue (array: unknown) {
   return isList(array) ? array[0] : array
 }
 
@@ -243,7 +278,7 @@ export function firstListValue (array) {
  * @param {Array} array - The array to query
  * @return {*} - The last element of the given array
  */
-export function first (array) {
+export function first<T> (array: readonly T[]): T {
   return array[0]
 }
 
@@ -253,14 +288,14 @@ export function first (array) {
  * @param {Array} array - The array to query
  * @return {*} - The last element of the given array
  */
-export function last (array) {
+export function last<T> (array: readonly T[]): T {
   return array[array.length - 1]
 }
 
 /**
  * Get a random value from provided list
  */
-export function randomFromList (array) {
+export function randomFromList<T> (array: readonly T[]): T {
   return array[Math.floor(Math.random() * array.length)]
 }
 
@@ -272,7 +307,7 @@ export function randomFromList (array) {
  *
  * @returns {Object} object with element.id being keys, and elements of original array being values
  */
-export function listToMap (obj, data) {
+export function listToMap<T extends { id: PropertyKey }> (obj: Record<PropertyKey, T>, data: T): Record<PropertyKey, T> {
   obj[data.id] = data
   return obj
 }
@@ -287,10 +322,12 @@ export function listToMap (obj, data) {
  * @param {*} a - first value in the iteration
  * @param {*} b - second value in the iteration
  * @return {number} - whether values should be re-arranged
+ * @Note: the casts below stand for JS's own relational ordering, which applies to any pair of
+ *    values (numbers, strings, dates, mixed) and which the type system cannot express.
  */
-export function sortAscending (a, b) {
-  if (a < b) return -1
-  if (a > b) return 1
+export function sortAscending (a: unknown, b: unknown): number {
+  if ((a as number) < (b as number)) return -1
+  if ((a as number) > (b as number)) return 1
   return 0
 }
 
@@ -305,9 +342,9 @@ export function sortAscending (a, b) {
  * @param {*} b - second value in the iteration
  * @return {number} - whether values should be re-arranged
  */
-export function sortDescending (a, b) {
-  if (a < b) return 1
-  if (a > b) return -1
+export function sortDescending (a: unknown, b: unknown): number {
+  if ((a as number) < (b as number)) return 1
+  if ((a as number) > (b as number)) return -1
   return 0
 }
 
@@ -322,9 +359,9 @@ export function sortDescending (a, b) {
  * @param {String} [order] - enum ['asc', 'desc']
  * @return {Function} - to be used as argument for native Array.sort()
  */
-export function sort (key, order = 'asc') {
+export function sort (key?: string, order: string = 'asc'): (a: unknown, b: unknown) => number {
   const sortFunc = order === 'asc' ? sortAscending : sortDescending
-  return (a, b) => sortFunc(a[key], b[key])
+  return (a, b) => sortFunc((a as Obj)[key as string], (b as Obj)[key as string])
 }
 
 /**
@@ -338,25 +375,25 @@ export function sort (key, order = 'asc') {
  *
  * @param {String|Function} args - compare function, object Key, or Path (prepend string with '-' for descending)
  */
-export function by (...args) {
+export function by (...args: Array<string | CompareFn>): (a: unknown, b: unknown) => number {
   return (a, b) => {
     let result = 0
 
     // Loop through given sort arguments
     for (let key of args) {
       if (key.constructor === String) {
-        if (key.indexOf('-') === 0) {
-          key = key.substring(1)
+        if ((key as string).indexOf('-') === 0) {
+          key = (key as string).substring(1)
           if (key.indexOf('.') > 0) {
             result = sortDescending(get(a, key), get(b, key))
           } else {
-            result = sortDescending(a[key], b[key])
+            result = sortDescending((a as Obj)[key], (b as Obj)[key])
           }
         } else {
-          if (key.indexOf('.') > 0) {
+          if ((key as string).indexOf('.') > 0) {
             result = sortAscending(get(a, key), get(b, key))
           } else {
-            result = sortAscending(a[key], b[key])
+            result = sortAscending((a as Obj)[key as string], (b as Obj)[key as string])
           }
         }
 
@@ -364,7 +401,7 @@ export function by (...args) {
         // else keep looping to the next sort argument
         if (result) return result
       } else if (key.constructor === Function) {
-        result = key(a, b)
+        result = (key as CompareFn)(a, b)
 
         // exit function when has sorting to perform,
         // else keep looping to the next sort argument
@@ -382,7 +419,7 @@ export function by (...args) {
  * @param {Array} list - to shuffle values for
  * @return {Array} list - mutated with shuffled values
  */
-export function shuffle (list) {
+export function shuffle<T> (list: T[]): T[] {
   for (let i = list.length - 1; i > 0; i--) {
     let j = Math.floor(Math.random() * (i + 1));
     [list[i], list[j]] = [list[j], list[i]]
diff --git a/src/core/utils/classNames.js b/src/core/utils/classNames.ts
similarity index 56%
rename from src/core/utils/classNames.js
rename to src/core/utils/classNames.ts
index c764d6da..a558f8cb 100644
--- a/src/core/utils/classNames.js
+++ b/src/core/utils/classNames.ts
@@ -1,16 +1,22 @@
 const hasOwn = {}.hasOwnProperty
 
-function toVal (mix) {
-    let k
-    let y
+/** A dictionary whose truthy keys become class names. Values may be anything — only truthiness is read. */
+export interface ClassDictionary {
+    [key: string]: unknown
+}
+
+/** Anything `classNames()` accepts, including nested arrays. */
+export type ClassValue = string | number | boolean | null | undefined | ClassDictionary | ClassValue[]
+
+function toVal (mix: ClassValue): string {
     let str = ''
     if (typeof mix === 'string' || typeof mix === 'number') {
         str += mix
     } else if (typeof mix === 'object' && mix != null) {
         if (Array.isArray(mix)) {
-            for (k = 0; k < mix.length; k++) {
+            for (let k = 0; k < mix.length; k++) {
                 if (mix[k]) {
-                    y = toVal(mix[k])
+                    const y = toVal(mix[k])
                     if (y) {
                         if (str) str += ' '
                         str += y
@@ -18,7 +24,7 @@ function toVal (mix) {
                 }
             }
         } else {
-            for (k in mix) {
+            for (const k in mix) {
                 if (hasOwn.call(mix, k) && mix[k]) {
                     if (str) str += ' '
                     str += k
@@ -31,16 +37,14 @@ function toVal (mix) {
 
 /**
  * Join class names (subset of the `classnames` package API).
- * @param {...*} args
- * @returns {string}
  */
-export default function classNames () {
+export default function classNames (...args: ClassValue[]): string {
     let i = 0
-    let tmp
-    let x
+    let tmp: ClassValue
+    let x: string
     let str = ''
-    while (i < arguments.length) {
-        tmp = arguments[i++]
+    while (i < args.length) {
+        tmp = args[i++]
         if (tmp) {
             x = toVal(tmp)
             if (x) {
diff --git a/src/core/utils/codec.js b/src/core/utils/codec.ts
similarity index 60%
rename from src/core/utils/codec.js
rename to src/core/utils/codec.ts
index 507532cd..33a01cad 100644
--- a/src/core/utils/codec.js
+++ b/src/core/utils/codec.ts
@@ -1,3 +1,6 @@
+/** Replacer accepted by `toJSON`, matching `JSON.stringify`'s second argument. */
+type JSONReplacer = (this: unknown, key: string, value: unknown) => unknown
+
 /**
  * Converts given value to a JSON string if necessary.
  * Circular references are replaced with the string "[Circular]".
@@ -6,7 +9,10 @@
  * @param {*} args - additional options (replacer, space)
  * @return {string}
  */
-export function toJSON (data, ...args) {
+export function toJSON (
+  data: unknown,
+  ...args: [replacer?: JSONReplacer | null, space?: string | number]
+): any {
   if (typeof data !== 'object') return data
   const [replacer, space] = args
   return JSON.stringify(data, withCircularGuard(replacer), space)
@@ -18,17 +24,17 @@ export function toJSON (data, ...args) {
  * @param {string} data - the string to be parsed
  * @return {Object|Null} - a JavaScript object if parsed successfully, null if not
  */
-export function fromJSON (data) {
+export function fromJSON (data: unknown): any {
   try {
-    return JSON.parse(data)
+    return JSON.parse(data as string)
   } catch (e) {
     return data
   }
 }
 
-function withCircularGuard (replacer) {
-  const seen = new WeakSet()
-  return function (key, value) {
+function withCircularGuard (replacer: JSONReplacer | null | undefined): JSONReplacer {
+  const seen = new WeakSet<object>()
+  return function (this: unknown, key: string, value: unknown) {
     if (typeof value === 'object' && value !== null) {
       if (seen.has(value)) return '[Circular]'
       seen.add(value)
diff --git a/src/core/utils/components.js b/src/core/utils/components.js
deleted file mode 100644
index 38539a44..00000000
--- a/src/core/utils/components.js
+++ /dev/null
@@ -1 +0,0 @@
-export { default as cn } from './classNames.js'
diff --git a/src/core/utils/components.ts b/src/core/utils/components.ts
new file mode 100644
index 00000000..1280590e
--- /dev/null
+++ b/src/core/utils/components.ts
@@ -0,0 +1 @@
+export { default as cn } from './classNames'
diff --git a/src/core/utils/constants.js b/src/core/utils/constants.ts
similarity index 95%
rename from src/core/utils/constants.js
rename to src/core/utils/constants.ts
index ce35496b..61da839e 100644
--- a/src/core/utils/constants.js
+++ b/src/core/utils/constants.ts
@@ -158,7 +158,7 @@ export const KEY = {
   X: 88,
   Y: 89,
   Z: 90,
-}
+} as const
 
 /* Distance */
 export const ONE_MM = 1
@@ -263,16 +263,19 @@ export const LANGUAGE = {
 	YIDDISH:    {_: 'yi', lang: 'ייִדיש',         'en': 'Yiddish'},
 	ARABIC:     {_: 'ar', lang: 'العَرَبِيَّة‎',    'en': 'Arabic'},
 	AFRIKAANS:  {_: 'af', lang: 'Afrikaans',     'en': 'Afrikaans'},
-}
+} as const
 
 /**
  * Object mapping of language to their code
+ * @note: every value is replaced with its `_` code by the loop below; the spread of `LANGUAGE`
+ *    exists only so IDEs suggest the keys, and is never observable with its object values.
  */
+type LanguageCode = {[K in keyof typeof LANGUAGE]: (typeof LANGUAGE)[K]['_']}
 export const l = {
 	...LANGUAGE // enable IDE suggestion
-}
+} as unknown as LanguageCode
 for (const key in LANGUAGE) {
-	l[key] = LANGUAGE[key]._
+	(l as unknown as Record<string, string>)[key] = LANGUAGE[key as keyof typeof LANGUAGE]._
 }
 
 /**
@@ -303,11 +306,11 @@ export const LANGUAGE_LEVEL = {
 		_: 5,
 		[l.ENGLISH]: 'Native',
 	},
-}
+} as const
 
 /* Mappings */
 export const SORT_ORDER = {
 	0: 'sort',
 	1: 'asc',
 	[-1]: 'desc',
-}
+} as const
diff --git a/src/core/utils/definitions.js b/src/core/utils/definitions.js
deleted file mode 100644
index 53738beb..00000000
--- a/src/core/utils/definitions.js
+++ /dev/null
@@ -1,216 +0,0 @@
-import { Active } from './_envs.js'
-import { LANGUAGE } from './constants.js'
-
-const hasOwn = (object, key) => Object.prototype.hasOwnProperty.call(object, key)
-
-const setOwn = (object, key, value) => Object.defineProperty(object, key, {
-  configurable: true,
-  enumerable: true,
-  writable: true,
-  value,
-})
-
-/**
- * PROJECT DEFINITIONS =========================================================
- * =============================================================================
- */
-
-/**
- * Define Getters and Setters for Definition Object to avoid duplicate definitions by mistake
- *
- * @example:
- *    const FIELD = definitionSetup('TYPE', 'ID')
- *    FIELD.TYPE = {
- *      EXPAND: 'Expand',
- *      COLLAPSE: 'Expand', // throws error because of duplicate value 'Expand'
- *    }
- *    ....
- *    FIELD.TYPE = {
- *      EXPAND: 'Expand' // throws error the second time because of duplicate key 'EXPAND'
- *    }
- *
- * @param {String} props - list of definition keys
- * @returns {Object} DEFINITION - new object with getters and setters defined for given `props`
- */
-export function definitionSetup (...props) {
-  const DEFINITION = {}
-  props.forEach(prop => {
-    const _key = `_${prop}`
-    Object.defineProperty(DEFINITION, prop, {
-      get () {
-        return this[_key]
-      },
-      set (def) {
-        if (!this[_key]) this[_key] = {}
-        const data = this[_key]
-        for (const key of Object.keys(def)) {
-          if (hasOwn(data, key))
-            throw new Error(`Duplicate ${prop}[${key}] definition ${JSON.stringify(def, null, 2)}`)
-          const value = def[key]
-          for (const i of Object.keys(data)) {
-            if (data[i] === value)
-              throw new Error(`Duplicate ${prop}[${key}] definition value "${value}" ${JSON.stringify(def, null, 2)}`)
-          }
-          setOwn(data, key, value)
-        }
-        return data
-      },
-    })
-  })
-  return DEFINITION
-}
-
-/**
- * Map Object Definition by its Underscore Value
- *
- * @example:
- *  definitionByValue(LANGUAGE)
- *  >>> {
- *        'en': {
- *          _: 'en',
- *          'en': 'English'
- *          ...
- *        },
- *        ...
- *      }
- *
- * @param {Object<KEY<_...>>|Array<_...>} DEFINITION - key/value pairs of variable name with its underscore value
- * @return {Object<_<_...>>} definition - grouped by its underscore value
- */
-export function definitionByValue (DEFINITION) {
-  const result = {}
-  for (const index of Object.keys(DEFINITION)) {
-    const def = DEFINITION[index]
-    setOwn(result, def._, def)
-  }
-  return result
-}
-
-/**
- * Generate Enumerable List of Values from given Object Definition
- *
- * @example:
- *  enumFrom(LANGUAGE)
- *  >>> ['en', 'fr'...]
- *
- * @param {Object<KEY<_...>>|Array<_...>} DEFINITION - key/value pairs of variable name with its underscore value
- * @returns {Array<String>} enums - list of enumerable values
- */
-export function enumFrom (DEFINITION) {
-  const list = []
-  for (const index of Object.keys(DEFINITION)) {
-    list.push(DEFINITION[index]._)
-  }
-  return list
-}
-
-/*
- * Extract Dropdown Options by Language for Given Object Definition
- *
- * @example:
- *    const options = optionsFrom(LANGUAGE)
- *    <Dropdown options={options.items} .../> // options for currently active language can be accessed via `items`,
- *    <Dropdown options={options[LANGUAGE.ENGLISH._]} .../> // or directly via language _
- *
- * @param {Object<KEY<_...>>|Array<_...>} DEFINITION - key/value pairs of variable name with its underscore value
- * @return {Object<items, lang[{text, value}]>} options - grouped by language underscore value, with .items pointing to active lang
- */
-export function optionsFrom (DEFINITION) {
-  const options = {
-    get items () {
-      return this[Active.LANG._] || this[LANGUAGE.ENGLISH._] || []
-    }
-  }
-  for (const index of Object.keys(DEFINITION)) {
-    const {_: value, ...langs} = DEFINITION[index]
-    for (const lang of Object.keys(langs)) {
-      const text = langs[lang]
-      // Dropdown `value` cannot be array because of shallow match
-      const languageOptions = hasOwn(options, lang) ? options[lang] : []
-      setOwn(options, lang, languageOptions.concat({text, value: Array.isArray(value) ? value.join(',') : value}))
-    }
-  }
-  return options
-}
-
-/**
- * Prepare definitions for localisation, so they can be accessed via .name property without needing active language _
- *
- * @example:
- *    localise(LANGUAGE)
- *    console.log(LANGUAGE.ENGLISH.name)
- *    >>> English
- *
- * @param {Object|Object<KEY<_...>>|Array<_...>} DEFINITION - key/value pairs of variable name with its _ value
- *    Multiple definitions can be nested unlimited times inside a single object.
- */
-export function localise (DEFINITION) {
-  for (const index of Object.keys(DEFINITION)) {
-    const definition = DEFINITION[index]
-    const {_, name} = definition
-    if (name == null && _ != null) {
-      Object.defineProperty(DEFINITION[index], 'name', {
-        get () {
-          return this[Active.LANG._] != null
-            ? this[Active.LANG._]
-            : (this[LANGUAGE.ENGLISH._] != null ? this[LANGUAGE.ENGLISH._] : String(_))
-        }
-      })
-    } else {
-      if (definition.constructor === Object) localise(definition, Active) // recursively process nested definitions
-    }
-  }
-}
-
-/**
- * Prepare translations for localisation by mutation, so they can be accessed directly via .TEXT property
- * @Note: can be applied repeatedly to add new translations or languages after requests from API
- *
- * @example:
- *    const _ = localiseTranslation(TRANSLATIONS)
- *    log(_.SEARCH)
- *    # if active language is English
- *    >>> 'Search'
- *    # if active language is Russian
- *    >>> 'Поиск'
- *
- * Add language:
- *    _.SEARCH = {
- *      ..., // previous definitions
- *      [l.CHINESE]: '搜索', // language addition
- *    }
- *    log(_.SEARCH)
- *    # if active language is Chinese
- *    >>> 搜索
- *
- * @param {Object|Object<KEY<_...>>} TRANSLATION - key/value pairs of variable name with its localised values
- * @returns {Object} translations - with all definitions as javascript getters returning currently active language,
- *  (falls back to English if definition not found for active language, or empty string).
- */
-export function localiseTranslation (TRANSLATION) {
-  for (const KEY of Object.keys(TRANSLATION)) {
-    const _data = TRANSLATION[KEY]
-    // Update existing translations
-    if (hasOwn(localiseTranslation.instance, KEY)) {
-      localiseTranslation.instance[KEY] = _data
-    } else {
-      // Define translations for the first time
-      const _key = '~' + KEY
-      Object.defineProperty(localiseTranslation.instance, KEY, {
-        get () {
-          // initially cannot use setter to define translations, thus fallback to _data
-          const data = localiseTranslation.instance[_key] || (localiseTranslation.instance[_key] = _data)
-          return data[Active.LANG._] || data[Active.DEFAULT.LANGUAGE] || KEY || ''
-        },
-        set (data) {
-          // merge new translations with existing
-          localiseTranslation.instance[_key] = {...(localiseTranslation.instance[_key] || _data), ...data}
-        }
-      })
-    }
-  }
-  return localiseTranslation.instance
-}
-
-localiseTranslation.instance = {}
-localiseTranslation.queriedById = {}
diff --git a/src/core/utils/definitions.ts b/src/core/utils/definitions.ts
new file mode 100644
index 00000000..9fe00777
--- /dev/null
+++ b/src/core/utils/definitions.ts
@@ -0,0 +1,274 @@
+import { Active } from './_envs'
+import { LANGUAGE } from './constants'
+
+/**
+ * @Note on the types (§9.6-E1): the values inside a definition are whatever the platform puts
+ * there - a string code, a number, a list of codes, a localised label, or a nested definition.
+ * They are typed `unknown` rather than `string`, because every one of the shapes above really
+ * occurs (see `__tests__/definitions.enums-and-localization.test.js`). Nothing here narrows or
+ * validates its input: these helpers walk plain objects and hand back what they found.
+ */
+
+/** A single definition: its `_` value plus localised labels keyed by language code */
+export interface DefinitionEntry {
+  /** canonical value of the definition - a code, a number, or a list of codes */
+  _?: unknown
+
+  /** localised label under a language code (`en`, `ru`, ...), or any other metadata */
+  [key: string]: unknown
+}
+
+/** Definitions as declared by the platform: keyed by variable name, or as a plain list */
+export type DefinitionSource = Record<string, DefinitionEntry> | readonly DefinitionEntry[]
+
+/** A group of definitions assigned to one `definitionSetup` prop (e.g. `FIELD.TYPE`) */
+export type Definition = Record<string, unknown>
+
+/** One `<Dropdown options>` entry produced by {@link optionsFrom} */
+export interface DefinitionOption {
+  /** localised label of the definition in the language this list belongs to */
+  text: unknown
+
+  /** the definition `_` value, with list values joined by `,` (Dropdown matches shallowly) */
+  value: unknown
+}
+
+/** Dropdown options grouped by language code, with `items` pointing at the active language */
+export interface DefinitionOptions {
+  /** options of the currently active language, falling back to English and then to `[]` */
+  readonly items: DefinitionOption[]
+
+  [lang: string]: DefinitionOption[]
+}
+
+/** Localised values of a single phrase, keyed by language code */
+export type Translation = Record<string, string>
+
+/**
+ * The single translation instance: a phrase `KEY` reads back as the localised `string`, while the
+ * `~KEY` slot behind it holds the raw {@link Translation} that the getter and setter work with.
+ */
+export type Translations = Record<string, string | Translation>
+
+const hasOwn = (object: object, key: PropertyKey): boolean => Object.prototype.hasOwnProperty.call(object, key)
+
+/**
+ * @Note: `key` is `unknown` because definition `_` values are - `defineProperty` coerces a
+ * non-symbol key to a string, exactly as it did before this file was typed.
+ */
+const setOwn = <T extends object> (object: T, key: unknown, value: unknown): T => Object.defineProperty(object, key as PropertyKey, {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  value,
+})
+
+/**
+ * PROJECT DEFINITIONS =========================================================
+ * =============================================================================
+ */
+
+/**
+ * Define Getters and Setters for Definition Object to avoid duplicate definitions by mistake
+ *
+ * @example:
+ *    const FIELD = definitionSetup('TYPE', 'ID')
+ *    FIELD.TYPE = {
+ *      EXPAND: 'Expand',
+ *      COLLAPSE: 'Expand', // throws error because of duplicate value 'Expand'
+ *    }
+ *    ....
+ *    FIELD.TYPE = {
+ *      EXPAND: 'Expand' // throws error the second time because of duplicate key 'EXPAND'
+ *    }
+ *
+ * @param props - list of definition keys
+ * @returns DEFINITION - new object with getters and setters defined for given `props`
+ *  @Note: each prop reads back `undefined` until it is assigned for the first time; it is typed as
+ *    always present because every call site assigns on module initialisation.
+ */
+export function definitionSetup<P extends string> (...props: P[]): Record<P, Definition> {
+  const DEFINITION = {} as Record<P, Definition>
+  props.forEach(prop => {
+    const _key = `_${prop}`
+    Object.defineProperty(DEFINITION, prop, {
+      get (this: Record<string, Definition | undefined>) {
+        return this[_key]
+      },
+      set (this: Record<string, Definition | undefined>, def: Definition) {
+        if (!this[_key]) this[_key] = {}
+        const data = this[_key] as Definition
+        for (const key of Object.keys(def)) {
+          if (hasOwn(data, key))
+            throw new Error(`Duplicate ${prop}[${key}] definition ${JSON.stringify(def, null, 2)}`)
+          const value = def[key]
+          for (const i of Object.keys(data)) {
+            if (data[i] === value)
+              throw new Error(`Duplicate ${prop}[${key}] definition value "${value}" ${JSON.stringify(def, null, 2)}`)
+          }
+          setOwn(data, key, value)
+        }
+        return data
+      },
+    })
+  })
+  return DEFINITION
+}
+
+/**
+ * Map Object Definition by its Underscore Value
+ *
+ * @example:
+ *  definitionByValue(LANGUAGE)
+ *  >>> {
+ *        'en': {
+ *          _: 'en',
+ *          'en': 'English'
+ *          ...
+ *        },
+ *        ...
+ *      }
+ *
+ * @param DEFINITION - key/value pairs of variable name with its underscore value
+ * @return definition - grouped by its underscore value
+ */
+export function definitionByValue (DEFINITION: DefinitionSource): Record<string, DefinitionEntry> {
+  const result: Record<string, DefinitionEntry> = {}
+  for (const index of Object.keys(DEFINITION)) {
+    const def = (DEFINITION as Record<string, DefinitionEntry>)[index]
+    setOwn(result, def._, def)
+  }
+  return result
+}
+
+/**
+ * Generate Enumerable List of Values from given Object Definition
+ *
+ * @example:
+ *  enumFrom(LANGUAGE)
+ *  >>> ['en', 'fr'...]
+ *
+ * @param DEFINITION - key/value pairs of variable name with its underscore value
+ * @returns enums - list of enumerable values (whatever `_` holds: codes, numbers, or lists)
+ */
+export function enumFrom (DEFINITION: DefinitionSource): unknown[] {
+  const list: unknown[] = []
+  for (const index of Object.keys(DEFINITION)) {
+    list.push((DEFINITION as Record<string, DefinitionEntry>)[index]._)
+  }
+  return list
+}
+
+/*
+ * Extract Dropdown Options by Language for Given Object Definition
+ *
+ * @example:
+ *    const options = optionsFrom(LANGUAGE)
+ *    <Dropdown options={options.items} .../> // options for currently active language can be accessed via `items`,
+ *    <Dropdown options={options[LANGUAGE.ENGLISH._]} .../> // or directly via language _
+ *
+ * @param DEFINITION - key/value pairs of variable name with its underscore value
+ * @return options - grouped by language underscore value, with .items pointing to active lang
+ */
+export function optionsFrom (DEFINITION: DefinitionSource): DefinitionOptions {
+  const options: DefinitionOptions = {
+    get items () {
+      // @Note: `this` is the options object itself, indexed by language code
+      return (this as DefinitionOptions)[Active.LANG._] || (this as DefinitionOptions)[LANGUAGE.ENGLISH._] || []
+    }
+  }
+  for (const index of Object.keys(DEFINITION)) {
+    const {_: value, ...langs} = (DEFINITION as Record<string, DefinitionEntry>)[index]
+    for (const lang of Object.keys(langs)) {
+      const text = langs[lang]
+      // Dropdown `value` cannot be array because of shallow match
+      const languageOptions = hasOwn(options, lang) ? options[lang] : []
+      setOwn(options, lang, languageOptions.concat({text, value: Array.isArray(value) ? value.join(',') : value}))
+    }
+  }
+  return options
+}
+
+/**
+ * Prepare definitions for localisation, so they can be accessed via .name property without needing active language _
+ *
+ * @example:
+ *    localise(LANGUAGE)
+ *    console.log(LANGUAGE.ENGLISH.name)
+ *    >>> English
+ *
+ * @param DEFINITION - key/value pairs of variable name with its _ value
+ *    Multiple definitions can be nested unlimited times inside a single object.
+ * @param _Active - vestigial: passed by the recursive call below and never read
+ */
+export function localise (DEFINITION: Record<string, unknown>, _Active?: unknown): void {
+  for (const index of Object.keys(DEFINITION)) {
+    const definition = DEFINITION[index] as DefinitionEntry
+    const {_, name} = definition
+    if (name == null && _ != null) {
+      Object.defineProperty(DEFINITION[index], 'name', {
+        get (this: DefinitionEntry) {
+          return this[Active.LANG._] != null
+            ? this[Active.LANG._]
+            : (this[LANGUAGE.ENGLISH._] != null ? this[LANGUAGE.ENGLISH._] : String(_))
+        }
+      })
+    } else {
+      if (definition.constructor === Object) localise(definition, Active) // recursively process nested definitions
+    }
+  }
+}
+
+/**
+ * Prepare translations for localisation by mutation, so they can be accessed directly via .TEXT property
+ * @Note: can be applied repeatedly to add new translations or languages after requests from API
+ *
+ * @example:
+ *    const _ = localiseTranslation(TRANSLATIONS)
+ *    log(_.SEARCH)
+ *    # if active language is English
+ *    >>> 'Search'
+ *    # if active language is Russian
+ *    >>> 'Поиск'
+ *
+ * Add language:
+ *    _.SEARCH = {
+ *      ..., // previous definitions
+ *      [l.CHINESE]: '搜索', // language addition
+ *    }
+ *    log(_.SEARCH)
+ *    # if active language is Chinese
+ *    >>> 搜索
+ *
+ * @param TRANSLATION - key/value pairs of variable name with its localised values
+ * @returns translations - with all definitions as javascript getters returning currently active language,
+ *  (falls back to English if definition not found for active language, or empty string).
+ */
+export function localiseTranslation (TRANSLATION: Record<string, Translation>): Translations {
+  for (const KEY of Object.keys(TRANSLATION)) {
+    const _data = TRANSLATION[KEY]
+    // Update existing translations
+    if (hasOwn(localiseTranslation.instance, KEY)) {
+      localiseTranslation.instance[KEY] = _data
+    } else {
+      // Define translations for the first time
+      const _key = '~' + KEY
+      Object.defineProperty(localiseTranslation.instance, KEY, {
+        get () {
+          // initially cannot use setter to define translations, thus fallback to _data
+          // @Note: the `~` slot only ever holds the raw translation object
+          const data = (localiseTranslation.instance[_key] || (localiseTranslation.instance[_key] = _data)) as Translation
+          return data[Active.LANG._] || data[Active.DEFAULT.LANGUAGE] || KEY || ''
+        },
+        set (data: Translation) {
+          // merge new translations with existing
+          localiseTranslation.instance[_key] = {...(localiseTranslation.instance[_key] as Translation | undefined || _data), ...data}
+        }
+      })
+    }
+  }
+  return localiseTranslation.instance
+}
+
+localiseTranslation.instance = {} as Translations
+localiseTranslation.queriedById = {} as Record<PropertyKey, unknown>
diff --git a/src/core/utils/function.js b/src/core/utils/function.ts
similarity index 51%
rename from src/core/utils/function.js
rename to src/core/utils/function.ts
index b59265b7..702a3738 100644
--- a/src/core/utils/function.js
+++ b/src/core/utils/function.ts
@@ -1,25 +1,40 @@
-import { throttle as _throttle } from './lodash-lite.js'
-import { __DEV__ } from './_envs.js'
-import { isInListAny } from './array.js'
-import { TIME_DURATION_INSTANT } from './constants.js'
+import { throttle as _throttle } from './lodash-lite'
+import { __DEV__ } from './_envs'
+import { isInListAny } from './array'
+import { TIME_DURATION_INSTANT } from './constants'
 
 /**
  * FUNCTION HELPERS ============================================================
  * =============================================================================
  */
 
+/**
+ * Any callable, used ONLY as the constraint of the `debounce`/`throttle` generics.
+ *
+ * `never[]` is what makes it accept every concrete function type a caller already has, without
+ * this module dictating what that function may take; `Parameters<F>`/`ReturnType<F>` then recover
+ * the caller's real signature for the wrapper it gets back.
+ */
+type AnyFn = (...args: never[]) => unknown
+
+/** The option bag `debounce` reads — only `leading`, exactly as at runtime. */
+type DebounceOptions = { leading?: boolean }
+
+/** The option bag `throttle` forwards verbatim to the lodash-lite implementation. */
+type ThrottleOptions = { leading?: boolean, trailing?: boolean }
+
 /**
  * Checks if passed argument is of type function.
  *
  * @param {*} func - the thing we are checking for being a function
  * @return {boolean}
  */
-export function isFunction (func) {
+export function isFunction (func: unknown): func is Function {
 	// When 'GeneratorFunction' is defined globally, use it instead of isFunction.Generator
 	return !!func && (
-		func.constructor === Function ||
-		func.constructor === isFunction.Async ||
-		func.constructor === isFunction.Generator
+		(func as { constructor?: unknown }).constructor === Function ||
+		(func as { constructor?: unknown }).constructor === isFunction.Async ||
+		(func as { constructor?: unknown }).constructor === isFunction.Generator
 	)
 }
 
@@ -32,8 +47,8 @@ isFunction.Async = (async () => {}).constructor
  * @param {Function} func - to check
  * @returns {Boolean} true - if it is
  */
-export function isAsync (func) {
-	return func.constructor.name === 'AsyncFunction'
+export function isAsync (func: unknown): boolean {
+	return (func as { constructor: { name: string } }).constructor.name === 'AsyncFunction'
 }
 
 /**
@@ -43,7 +58,7 @@ export function isAsync (func) {
  * @param {*} value - variable to check against enum
  * @param {Function} [self] - optional, the caller function's ${this} context
  */
-export function enumCheck (enums, value, self) {
+export function enumCheck (enums: readonly unknown[], value: unknown, self?: unknown): void {
 	if (!__DEV__) return
 
 	if (!isInListAny(enums, value)) {
@@ -60,16 +75,19 @@ export function enumCheck (enums, value, self) {
  * @param {Boolean} [leading] - whether to execute the Function immediately first
  * @returns {function(...[*]=)} - debounced
  */
-export function debounce (func, wait = TIME_DURATION_INSTANT, { leading } = {}) {
-	let timeout
+export function debounce<F extends AnyFn> (
+	func: F, wait: number = TIME_DURATION_INSTANT, { leading }: DebounceOptions = {},
+): (this: unknown, ...args: Parameters<F>) => void {
+	let timeout: ReturnType<typeof setTimeout> | null | undefined
 	let trailingCall = false
-	return function() {
+	return function(this: unknown) {
 		const self = this
 		const args = arguments
 
 		function later () {
 			timeout = null
-			if (!leading || trailingCall) func.apply(self, args)
+			if (!leading || trailingCall) (func as unknown as (this: unknown, ...a: unknown[]) => unknown)
+				.apply(self, args as unknown as unknown[])
 			trailingCall = false
 		}
 
@@ -79,7 +97,8 @@ export function debounce (func, wait = TIME_DURATION_INSTANT, { leading } = {})
 			if (leading) trailingCall = true
 		}
 		timeout = setTimeout(later, wait)
-		if (callNow) func.apply(self, args)
+		if (callNow) (func as unknown as (this: unknown, ...a: unknown[]) => unknown)
+			.apply(self, args as unknown as unknown[])
 	}
 }
 
@@ -96,6 +115,8 @@ export function debounce (func, wait = TIME_DURATION_INSTANT, { leading } = {})
  * @param {Object} [options]
  * @returns {function(...[*]=)} - throttled
  */
-export function throttle (func, wait = TIME_DURATION_INSTANT, options = {}) {
+export function throttle<F extends AnyFn> (
+	func: F, wait: number = TIME_DURATION_INSTANT, options: ThrottleOptions = {},
+): (this: unknown, ...args: Parameters<F>) => ReturnType<F> | undefined {
 	return _throttle(func, wait, options)
 }
diff --git a/src/core/utils/index.js b/src/core/utils/index.js
deleted file mode 100644
index 5b9cca47..00000000
--- a/src/core/utils/index.js
+++ /dev/null
@@ -1,11 +0,0 @@
-export * from './_envs.js'
-export * from './constants.js'
-export * from './definitions.js'
-export * from './array.js'
-export * from './codec.js'
-export * from './function.js'
-export * from './number.js'
-export * from './object.js'
-export * from './storage.js'
-export * from './string.js'
-export * from './utility.js'
diff --git a/src/core/utils/index.ts b/src/core/utils/index.ts
new file mode 100644
index 00000000..2fff6fe9
--- /dev/null
+++ b/src/core/utils/index.ts
@@ -0,0 +1,11 @@
+export * from './_envs'
+export * from './constants'
+export * from './definitions'
+export * from './array'
+export * from './codec'
+export * from './function'
+export * from './number'
+export * from './object'
+export * from './storage'
+export * from './string'
+export * from './utility'
diff --git a/src/core/utils/lodash-lite.js b/src/core/utils/lodash-lite.ts
similarity index 59%
rename from src/core/utils/lodash-lite.js
rename to src/core/utils/lodash-lite.ts
index c58e53cb..61cb2c46 100644
--- a/src/core/utils/lodash-lite.js
+++ b/src/core/utils/lodash-lite.ts
@@ -1,32 +1,73 @@
 // A tiny subset of lodash we rely on, implemented locally to avoid shipping lodash-es.
 // Intentionally limited API surface: only what this repo imports.
-
-function isObjectLike(value) {
+//
+// @Note on the types (§9.6-E1): these helpers are deliberately polymorphic — they take whatever a
+// caller hands them and guard at runtime. The types below stay LOOSE on purpose: `unknown` for the
+// values this module inspects, element generics only where the runtime genuinely passes a value
+// through, and no tightening of what any function accepts.
+//
+// Every `any` here is deliberate and confined to three places, none of which is a value this module
+// hands back to a caller:
+//   1. parameters of USER callbacks (iteratee, comparator, customizer) — a contravariant `unknown`
+//      there would reject every caller that annotates its own callback, e.g. `(a: Row, b: Row) => …`;
+//   2. the two relational comparisons in `min`/`max`, which are JS's own ordering over values the
+//      type system cannot order;
+//   3. `throttle`'s saved `arguments`, which is replayed verbatim through `Function.apply`.
+
+/** Anything this module walks with a computed key once it knows the value is object-like. */
+type Dict = Record<PropertyKey, unknown>
+
+/** The resolved form of an iteratee shorthand. Callback parameters are `any` — see the note above. */
+type IterateeFn = (value: any, index?: any, collection?: any) => unknown
+
+/**
+ * The shorthands `toIteratee` understands: a function, a `[path, value]` pair, a source object to
+ * match, or any other value — which is treated as a property path, exactly as at runtime. The
+ * constituents are spelled out rather than collapsed to `unknown` so that a callback argument still
+ * gets its parameters contextually typed.
+ */
+type Iteratee = IterateeFn | PropertyKey | boolean | bigint | readonly unknown[] | object | null | undefined
+
+/** Custom equality callback, as taken by `uniqWith`/`unionWith`. Truthy means "same value". */
+type Comparator = (a: any, b: any) => unknown
+
+/** `setWith`'s customizer: returns the container to create for a missing path segment. */
+type SetWithCustomizer = (nsValue: any, key: PropertyKey, nsObject: any) => unknown
+
+/** `mergeWith`'s customizer: a non-`undefined` return wins over the default merge. */
+type MergeCustomizer = (dstValue: any, srcValue: any, key: string, dst: any, src: any) => unknown
+
+/** A function whose signature this module does not constrain (`throttle`'s subject). */
+type AnyFunction = (...args: any) => any
+
+type ThrottleOptions = { leading?: boolean, trailing?: boolean }
+
+function isObjectLike(value: unknown): value is object {
 	return value != null && typeof value === 'object'
 }
 
-function isObject(value) {
+function isObject(value: unknown): value is object {
 	return value != null && (typeof value === 'object' || typeof value === 'function')
 }
 
-function sameValueZero(a, b) {
+function sameValueZero(a: unknown, b: unknown): boolean {
 	return a === b || (Number.isNaN(a) && Number.isNaN(b))
 }
 
-function enumerableKeys(value) {
-	return Object.keys(value).concat(
+function enumerableKeys(value: object): Array<string | symbol> {
+	return (Object.keys(value) as Array<string | symbol>).concat(
 		Object.getOwnPropertySymbols(value)
 			.filter((key) => Object.prototype.propertyIsEnumerable.call(value, key))
 	)
 }
 
-function isPlainObject(value) {
+function isPlainObject(value: unknown): value is Dict {
 	if (!isObjectLike(value)) return false
 	const proto = Object.getPrototypeOf(value)
 	return proto === Object.prototype || proto === null
 }
 
-function isEmpty(value) {
+function isEmpty(value: unknown): boolean {
 	if (value == null) return true
 	if (typeof value === 'string') return value.length === 0
 	if (Array.isArray(value)) return value.length === 0
@@ -35,7 +76,7 @@ function isEmpty(value) {
 	return false
 }
 
-function toPath(path) {
+function toPath(path: unknown): PropertyKey[] {
 	if (Array.isArray(path)) return path.slice()
 	if (path == null) return []
 	const str = String(path)
@@ -51,16 +92,16 @@ function toPath(path) {
 	// @Note: bracket indices become numbers here, unlike lodash which keeps every segment a
 	// string. `toPath` is internal, and `setWith` relies on the number to create arrays.
 	const re = /[^.[\]]+|\[(?:(-?\d+)|(["'])(.*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g
-	const out = []
+	const out: PropertyKey[] = []
 	if (str.charCodeAt(0) === 46 /* . */) out.push('')
-	str.replace(re, (_, index, _q, quoted) => {
+	str.replace(re, (_: string, index: string | undefined, _q: string | undefined, quoted: string | undefined) => {
 		out.push(index !== undefined ? Number(index) : (quoted !== undefined ? quoted : _))
 		return ''
 	})
 	return out
 }
 
-function get(object, path, defaultValue) {
+function get(object: unknown, path: unknown, defaultValue?: unknown): unknown {
 	const parts = toPath(path)
 	// An empty path resolves to nothing, never to `object` itself.
 	// Otherwise `get(data, '')` hands out the whole data object, and a config such as
@@ -69,31 +110,31 @@ function get(object, path, defaultValue) {
 	// key. We always return the fallback instead, so an empty path can never yield an object.
 	// `setWith` and `unset` treat an empty path as "no path" too.
 	if (parts.length === 0) return defaultValue
-	let cur = object
+	let cur: unknown = object
 	for (const key of parts) {
 		if (cur == null) return defaultValue
-		cur = cur[key]
+		cur = (cur as Dict)[key]
 	}
 	return cur === undefined ? defaultValue : cur
 }
 
-function hasPath(object, path) {
+function hasPath(object: unknown, path: unknown): boolean {
 	const parts = toPath(path)
 	if (parts.length === 0) return false
-	let cur = object
+	let cur: unknown = object
 	for (const key of parts) {
 		if (cur == null || !(key in Object(cur))) return false
-		cur = cur[key]
+		cur = (cur as Dict)[key]
 	}
 	return true
 }
 
-function setWith(object, path, value, customizer) {
+function setWith<T>(object: T, path: unknown, value: unknown, customizer?: SetWithCustomizer): T {
 	if (object == null) return object
 	const parts = toPath(path)
 	if (parts.length === 0) return object
 
-	let cur = object
+	let cur = object as unknown as Dict
 	for (let i = 0; i < parts.length; i++) {
 		const key = parts[i]
 		if (key === '__proto__' || key === 'constructor' || key === 'prototype') return object
@@ -111,12 +152,12 @@ function setWith(object, path, value, customizer) {
 			next = created == null ? (typeof nextKey === 'number' ? [] : {}) : created
 			cur[key] = next
 		}
-		cur = next
+		cur = next as Dict
 	}
 	return object
 }
 
-function unset(object, path) {
+function unset(object: unknown, path: unknown): boolean {
 	if (object == null) return false
 	const parts = toPath(path)
 	if (parts.length === 0) return false
@@ -124,70 +165,74 @@ function unset(object, path) {
 	const parent = parts.length === 1 ? object : get(object, parts.slice(0, -1))
 	if (parent == null) return false
 	if (Object.prototype.hasOwnProperty.call(parent, last)) {
-		delete parent[last]
+		delete (parent as Dict)[last]
 		return true
 	}
 	return false
 }
 
-function cloneDeep(value, seen = new Map()) {
+function cloneDeep<T>(value: T, seen: Map<unknown, unknown> = new Map()): T {
 	if (!isObjectLike(value)) return value
-	if (seen.has(value)) return seen.get(value)
+	if (seen.has(value)) return seen.get(value) as T
 
 	if (Array.isArray(value)) {
 		const out = new Array(value.length)
 		seen.set(value, out)
 		for (let i = 0; i < value.length; i++) out[i] = cloneDeep(value[i], seen)
-		return out
+		return out as T
 	}
-	if (value instanceof Date) return new Date(value.getTime())
-	if (value instanceof RegExp) return new RegExp(value.source, value.flags)
+	if (value instanceof Date) return new Date(value.getTime()) as T
+	if (value instanceof RegExp) return new RegExp(value.source, value.flags) as T
 	if (value instanceof Map) {
 		const out = new Map()
 		seen.set(value, out)
 		for (const [k, v] of value.entries()) out.set(cloneDeep(k, seen), cloneDeep(v, seen))
-		return out
+		return out as T
 	}
 	if (value instanceof Set) {
 		const out = new Set()
 		seen.set(value, out)
 		for (const v of value.values()) out.add(cloneDeep(v, seen))
-		return out
+		return out as T
 	}
 	if (isPlainObject(value)) {
-		const out = {}
+		const out: Dict = {}
 		seen.set(value, out)
 		for (const k of enumerableKeys(value)) out[k] = cloneDeep(value[k], seen)
-		return out
+		return out as T
 	}
 	// For class instances and other objects, keep reference as-is.
 	return value
 }
 
-function isEqual(a, b, seen = new Map()) {
+function isEqual(a: unknown, b: unknown, seen: Map<unknown, unknown> = new Map()): boolean {
 	if (a === b) return true
 	if (Number.isNaN(a) && Number.isNaN(b)) return true
 	if (!isObjectLike(a) || !isObjectLike(b)) return false
 	if (a.constructor !== b.constructor) return false
+	// From here on `a` and `b` share a constructor, which is what lets every `b as ...` below
+	// stand: whatever narrowed `a` describes `b` just as well.
 
 	const seenKey = seen.get(a)
 	if (seenKey && seenKey === b) return true
 	seen.set(a, b)
 
 	if (Array.isArray(a)) {
-		if (a.length !== b.length) return false
-		for (let i = 0; i < a.length; i++) if (!isEqual(a[i], b[i], seen)) return false
+		const bArray = b as unknown[]
+		if (a.length !== bArray.length) return false
+		for (let i = 0; i < a.length; i++) if (!isEqual(a[i], bArray[i], seen)) return false
 		return true
 	}
-	if (a instanceof Date) return sameValueZero(a.getTime(), b.getTime())
-	if (a instanceof RegExp) return a.source === b.source && a.flags === b.flags
+	if (a instanceof Date) return sameValueZero(a.getTime(), (b as Date).getTime())
+	if (a instanceof RegExp) return a.source === (b as RegExp).source && a.flags === (b as RegExp).flags
 	if (a instanceof Number || a instanceof String || a instanceof Boolean) {
-		return sameValueZero(a.valueOf(), b.valueOf())
+		return sameValueZero(a.valueOf(), (b as Number | String | Boolean).valueOf())
 	}
-	if (a instanceof Error) return a.name === b.name && a.message === b.message
+	if (a instanceof Error) return a.name === (b as Error).name && a.message === (b as Error).message
 	if (a instanceof Map) {
-		if (a.size !== b.size) return false
-		const remaining = [...b.entries()]
+		const bMap = b as Map<unknown, unknown>
+		if (a.size !== bMap.size) return false
+		const remaining = [...bMap.entries()]
 		for (const [aKey, aValue] of a.entries()) {
 			let match = -1
 			for (let i = 0; i < remaining.length; i++) {
@@ -205,8 +250,9 @@ function isEqual(a, b, seen = new Map()) {
 		return true
 	}
 	if (a instanceof Set) {
-		if (a.size !== b.size) return false
-		const remaining = [...b.values()]
+		const bSet = b as Set<unknown>
+		if (a.size !== bSet.size) return false
+		const remaining = [...bSet.values()]
 		for (const aValue of a.values()) {
 			let match = -1
 			for (let i = 0; i < remaining.length; i++) {
@@ -223,28 +269,29 @@ function isEqual(a, b, seen = new Map()) {
 		return true
 	}
 	if (isPlainObject(a)) {
+		const bDict = b as Dict
 		const aKeys = enumerableKeys(a)
 		const bKeys = enumerableKeys(b)
 		if (aKeys.length !== bKeys.length) return false
 		for (const k of aKeys) {
 			if (!Object.prototype.hasOwnProperty.call(b, k)) return false
-			if (!isEqual(a[k], b[k], seen)) return false
+			if (!isEqual(a[k], bDict[k], seen)) return false
 		}
 		return true
 	}
 	return false
 }
 
-function property(path) {
+function property(path: unknown): (obj: unknown) => unknown {
 	return (obj) => get(obj, path)
 }
 
-function matches(source) {
+function matches(source: unknown): (object: unknown) => boolean {
 	const snapshot = cloneDeep(source)
 	return (object) => isMatch(object, snapshot)
 }
 
-function matchesProperty(path, sourceValue) {
+function matchesProperty(path: unknown, sourceValue: unknown): (object: unknown) => boolean {
 	const snapshot = cloneDeep(sourceValue)
 	return (object) => {
 		const value = get(object, path)
@@ -253,15 +300,15 @@ function matchesProperty(path, sourceValue) {
 	}
 }
 
-function toIteratee(value) {
-	if (typeof value === 'function') return value
-	if (value == null) return (item) => item
+function toIteratee(value: unknown): IterateeFn {
+	if (typeof value === 'function') return value as IterateeFn
+	if (value == null) return (item: unknown) => item
 	if (Array.isArray(value)) return matchesProperty(value[0], value[1])
 	if (isObjectLike(value)) return matches(value)
 	return property(value)
 }
 
-function isMatch(object, source) {
+function isMatch(object: unknown, source: unknown): boolean {
 	if (sameValueZero(object, source)) return true
 	if (Array.isArray(source)) {
 		if (!Array.isArray(object) || source.length > object.length) return false
@@ -284,7 +331,7 @@ function isMatch(object, source) {
 	for (const key of enumerableKeys(source)) {
 		if (!(key in Object(object))) return false
 		const sv = source[key]
-		const ov = object[key]
+		const ov = (object as Dict)[key]
 		if (isObjectLike(sv)) {
 			if (!isMatch(ov, sv)) return false
 		} else if (!sameValueZero(ov, sv)) {
@@ -294,7 +341,7 @@ function isMatch(object, source) {
 	return true
 }
 
-function some(collection, predicate) {
+function some(collection: unknown, predicate?: Iteratee): boolean {
 	if (collection == null) return false
 	const pred = toIteratee(predicate)
 	if (Array.isArray(collection)) {
@@ -303,15 +350,16 @@ function some(collection, predicate) {
 		}
 		return false
 	}
-	for (const key in collection) {
-		if (Object.prototype.hasOwnProperty.call(collection, key) && pred(collection[key], key, collection)) return true
+	const dict = collection as Dict
+	for (const key in dict) {
+		if (Object.prototype.hasOwnProperty.call(dict, key) && pred(dict[key], key, dict)) return true
 	}
 	return false
 }
 
-function flatten(array) {
+function flatten<T>(array: ReadonlyArray<T | readonly T[]> | null | undefined): T[] {
 	if (!Array.isArray(array)) return []
-	const out = []
+	const out: T[] = []
 	for (const item of array) {
 		if (Array.isArray(item)) out.push(...item)
 		else out.push(item)
@@ -319,39 +367,43 @@ function flatten(array) {
 	return out
 }
 
-function min(array) {
+function min<T>(array: readonly T[] | null | undefined): T | undefined {
 	if (!Array.isArray(array) || array.length === 0) return undefined
-	let m
+	let m: T | undefined
 	for (const value of array) {
 		if (value == null || Number.isNaN(value) || typeof value === 'symbol') continue
-		if (m === undefined || value < m) m = value
+		// `<` is JS's own relational comparison over values the type system cannot order
+		// (numbers, strings and dates all reach this line); the casts express that, and change
+		// nothing at runtime.
+		if (m === undefined || (value as any) < (m as any)) m = value
 	}
 	return m
 }
 
-function max(array) {
+function max<T>(array: readonly T[] | null | undefined): T | undefined {
 	if (!Array.isArray(array) || array.length === 0) return undefined
-	let m
+	let m: T | undefined
 	for (const value of array) {
 		if (value == null || Number.isNaN(value) || typeof value === 'symbol') continue
-		if (m === undefined || value > m) m = value
+		// See the note in `min` about the relational-operator casts.
+		if (m === undefined || (value as any) > (m as any)) m = value
 	}
 	return m
 }
 
-function difference(array, values) {
+function difference<T>(array: readonly T[] | null | undefined, values?: unknown): T[] {
 	if (!Array.isArray(array)) return []
 	const remove = new Set(Array.isArray(values) ? values : [])
-	const out = []
+	const out: T[] = []
 	for (const value of array) if (!remove.has(value)) out.push(value)
 	return out
 }
 
-function intersection(...arrays) {
+function intersection<T>(...arrays: Array<readonly T[] | null | undefined>): T[] {
 	if (arrays.length === 0 || arrays.some((array) => !Array.isArray(array))) return []
-	const [first, ...rest] = arrays
+	const [first, ...rest] = arrays as Array<readonly T[]>
 	const restSets = rest.map((a) => new Set(a))
-	const out = []
+	const out: T[] = []
 	const seen = new Set()
 	for (const value of first) {
 		if (!seen.has(value) && restSets.every((set) => set.has(value))) {
@@ -362,8 +414,8 @@ function intersection(...arrays) {
 	return out
 }
 
-function union(...arrays) {
-	const out = []
+function union<T>(...arrays: Array<readonly T[] | null | undefined>): T[] {
+	const out: T[] = []
 	const seen = new Set()
 	for (const arr of arrays) {
 		if (!Array.isArray(arr)) continue
@@ -377,22 +429,22 @@ function union(...arrays) {
 	return out
 }
 
-function uniqWith(array, comparator) {
+function uniqWith<T>(array: readonly T[] | null | undefined, comparator?: Comparator): T[] {
 	if (!Array.isArray(array)) return []
 	if (typeof comparator !== 'function') return union(array)
-	const out = []
+	const out: T[] = []
 	for (const v of array) {
 		if (!out.some((o) => comparator(o, v))) out.push(v)
 	}
 	return out
 }
 
-function unionWith(...args) {
+function unionWith(...args: unknown[]): unknown[] {
 	const lastArg = args[args.length - 1]
-	const comparator = typeof lastArg === 'function' ? lastArg : null
+	const comparator = typeof lastArg === 'function' ? lastArg as Comparator : null
 	const arrays = comparator ? args.slice(0, -1) : args
-	if (!comparator) return union(...arrays)
-	const out = []
+	if (!comparator) return union(...arrays as Array<unknown[]>)
+	const out: unknown[] = []
 	for (const arr of arrays) {
 		if (!Array.isArray(arr)) continue
 		for (const v of arr) {
@@ -402,11 +454,11 @@ function unionWith(...args) {
 	return out
 }
 
-function unionBy(...args) {
+function unionBy(...args: unknown[]): unknown[] {
 	const lastArg = args[args.length - 1]
 	const iteratee = Array.isArray(lastArg) ? undefined : args.pop()
 	const it = toIteratee(iteratee)
-	const out = []
+	const out: unknown[] = []
 	const seen = new Set()
 	for (const arr of args) {
 		if (!Array.isArray(arr)) continue
@@ -421,32 +473,33 @@ function unionBy(...args) {
 	return out
 }
 
-function mergeWith(target, ...rest) {
+function mergeWith(target: unknown, ...rest: unknown[]): Dict {
 	target = target == null ? {} : Object(target)
 	const customizer = rest[rest.length - 1]
 	const sources = typeof customizer === 'function' ? rest.slice(0, -1) : rest
-	const cz = typeof customizer === 'function' ? customizer : null
+	const cz = typeof customizer === 'function' ? customizer as MergeCustomizer : null
 	for (const src of sources) {
-		_mergeInto(target, src, cz)
+		_mergeInto(target as Dict, src, cz)
 	}
-	return target
+	return target as Dict
 }
 
-function merge(target, ...sources) {
+function merge(target: unknown, ...sources: unknown[]): Dict {
 	return mergeWith(target, ...sources)
 }
 
-function _mergeInto(dst, src, customizer) {
+function _mergeInto(dst: Dict, src: unknown, customizer: MergeCustomizer | null): void {
 	if (!isObjectLike(src)) return
+	const source = src as Dict
 	// Lodash merge includes inherited enumerable string keys and skips sparse-array holes.
-	for (const key in src) {
+	for (const key in source) {
 		if (key === '__proto__') continue
-		const srcVal = src[key]
+		const srcVal = source[key]
 		// lodash merge/mergeWith skips `undefined` source values
 		if (srcVal === undefined) continue
 		const dstVal = dst[key]
 		if (customizer) {
-			const customized = customizer(dstVal, srcVal, key, dst, src)
+			const customized = customizer(dstVal, srcVal, key, dst, source)
 			if (customized !== undefined) {
 				dst[key] = customized
 				continue
@@ -457,25 +510,26 @@ function _mergeInto(dst, src, customizer) {
 			// Previous concat() broke form-data merge: a sparse [, , , {}] from a child form was appended after
 			// the master array instead of overlaying index 3, producing phantom rows.
 			if (!Array.isArray(dstVal)) dst[key] = []
-			_mergeInto(dst[key], srcVal, customizer)
+			_mergeInto(dst[key] as Dict, srcVal, customizer)
 		} else if (isPlainObject(srcVal)) {
 			if (!isPlainObject(dstVal)) dst[key] = {}
-			_mergeInto(dst[key], srcVal, customizer)
+			_mergeInto(dst[key] as Dict, srcVal, customizer)
 		} else {
 			dst[key] = srcVal
 		}
 	}
 }
 
-function throttle(func, wait, options = {}) {
+function throttle(func: AnyFunction, wait: number, options: ThrottleOptions = {}): AnyFunction {
 	let lastCallTime = 0
-	let timeoutId = null
-	let lastArgs
-	let lastThis
+	let timeoutId: ReturnType<typeof setTimeout> | null = null
+	// `arguments` of the last throttled call, kept verbatim for `func.apply`.
+	let lastArgs: any
+	let lastThis: unknown
 	const leading = options.leading !== false
 	const trailing = options.trailing !== false
 
-	function invoke(time) {
+	function invoke(time: number) {
 		lastCallTime = time
 		const args = lastArgs
 		const self = lastThis
@@ -483,14 +537,14 @@ function throttle(func, wait, options = {}) {
 		return func.apply(self, args)
 	}
 
-	function startTimer(remaining) {
+	function startTimer(remaining: number) {
 		timeoutId = setTimeout(() => {
 			timeoutId = null
 			if (trailing && lastArgs) invoke(Date.now())
 		}, remaining)
 	}
 
-	return function throttled() {
+	return function throttled(this: unknown) {
 		const now = Date.now()
 		if (!lastCallTime && leading === false) lastCallTime = now
 		const remaining = wait - (now - lastCallTime)
@@ -508,10 +562,16 @@ function throttle(func, wait, options = {}) {
 	}
 }
 
-function isNumber(value) {
+function isNumber(value: unknown): boolean {
 	return typeof value === 'number' || value instanceof Number
 }
 
+function capitalize(string: unknown): string {
+	const str = String(string == null ? '' : string)
+	if (!str) return ''
+	return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase()
+}
+
 export {
 	// core
 	get,
@@ -545,8 +605,3 @@ export {
 	capitalize,
 }
 
-function capitalize(string) {
-	string = String(string == null ? '' : string)
-	if (!string) return ''
-	return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase()
-}
diff --git a/src/core/utils/media.js b/src/core/utils/media.ts
similarity index 67%
rename from src/core/utils/media.js
rename to src/core/utils/media.ts
index fa42f107..3ac7721b 100644
--- a/src/core/utils/media.js
+++ b/src/core/utils/media.ts
@@ -1,4 +1,3 @@
-
 /**
  * MEDIA FUNCTIONS =============================================================
  * =============================================================================
@@ -13,11 +12,11 @@
  *        = sqrt(50/200)*10
  *        = 5
  *
- * @param {Number} res - resolution limit to compute width for
- * @param {Number} width - original dimension
- * @param {Number} height - original dimension
- * @returns {Number} width - for given `res`
+ * @param res - resolution limit to compute width for
+ * @param width - original dimension
+ * @param height - original dimension
+ * @returns width - for given `res`
  */
-export function widthScaled (res, width, height) {
+export function widthScaled (res: number, width: number, height: number): number {
   return Math.round(Math.sqrt(res / width / height) * width)
 }
diff --git a/src/core/utils/number.js b/src/core/utils/number.ts
similarity index 74%
rename from src/core/utils/number.js
rename to src/core/utils/number.ts
index 7e4d8deb..e3ff87e2 100644
--- a/src/core/utils/number.js
+++ b/src/core/utils/number.ts
@@ -1,11 +1,41 @@
-import { hasListValue } from './array.js'
-import { isInString } from './string.js'
+import { hasListValue } from './array'
+import { isInString } from './string'
 
 /**
  * NUMBER FUNCTIONS ============================================================
  * =============================================================================
  */
 
+/**
+ * @Note on the types (§9.6-E1): these helpers are deliberately forgiving about their inputs —
+ * callers pass numeric strings, `null` and non-finite values, and every function guards at runtime
+ * instead of rejecting them. The types stay LOOSE on purpose: `unknown` where a value is only
+ * inspected behind a runtime guard, `number | string` where the runtime coerces, and no tightening
+ * of what any function accepts.
+ */
+
+/** One entry of the list {@link startEndFromNumberRanges} scans; both bounds are optional and nullable. */
+type NumberRange = { from?: number | null, to?: number | null }
+
+/** The boundaries {@link startEndFromNumberRanges} returns; either side is missing when unresolved. */
+type NumberRangeBounds = { start: number | undefined, end: number | undefined }
+
+/** Options of {@link formatNumber} — every one is optional, like the runtime defaults below. */
+type FormatNumberOptions = {
+	decimals?: number | null,
+	delimits?: number,
+	sectionDelimiter?: string,
+	decimalDelimiter?: string,
+	ordinal?: boolean,
+}
+
+/**
+ * Exponent (as a key) to unit suffix, as used by {@link formatSI}.
+ * @Note: a caller may pass a PARTIAL map (see the `{0: 'B', 3: 'KiB'}` usage in tests) — a missing
+ *    exponent resolves to `undefined` at runtime and is stringified into the result, unchanged.
+ */
+type SiSuffixes = Record<string, string>
+
 /**
  * Checks if value is classified as a Number primitive or object.
  *
@@ -25,7 +55,7 @@ import { isInString } from './string.js'
  * @param {*} val - The value to check.
  * @returns {boolean} - Returns true if value is a number, else false.
  */
-export { isNumber } from './lodash-lite.js'
+export { isNumber } from './lodash-lite'
 
 /**
  * Returns true if the given variable is a number,
@@ -40,8 +70,9 @@ export { isNumber } from './lodash-lite.js'
  * @param {*} val
  * @returns {boolean}
  */
-export function isNumeric(val) {
-	return !isNaN(parseFloat(val)) && isFinite(val) // must use parseFloat, cannot use the faster Number()
+export function isNumeric(val: unknown): boolean {
+	// Note: the casts keep the JS coercion the two globals do on non-string/non-number input
+	return !isNaN(parseFloat(val as string)) && isFinite(val as number) // must use parseFloat, cannot use the faster Number()
 }
 
 /**
@@ -50,11 +81,13 @@ export function isNumeric(val) {
  * @param {Array<{from: Number, to: Number}>} arrayOfNumberRanges - to check for values
  * @returns {{start: Number|Undefined, end: Number|Undefined}}
  */
-export function startEndFromNumberRanges(arrayOfNumberRanges) {
+export function startEndFromNumberRanges(arrayOfNumberRanges?: readonly NumberRange[] | null): NumberRangeBounds {
 	if (!hasListValue(arrayOfNumberRanges)) return { start: undefined, end: undefined }
-	const start = (arrayOfNumberRanges.find(({ from }) => from != null) || {}).from
-	let end = ([...arrayOfNumberRanges].reverse().find(({ to }) => to != null) || {}).to
-	if (end <= start) end = undefined
+	const ranges = arrayOfNumberRanges as readonly NumberRange[]
+	const start = (ranges.find(({ from }) => from != null) || ({} as NumberRange)).from as number | undefined
+	let end = ([...ranges].reverse().find(({ to }) => to != null) || ({} as NumberRange)).to as number | undefined
+	// Note: the comparison is left as is — with either side missing it is `false` at runtime
+	if ((end as number) <= (start as number)) end = undefined
 	return { start, end }
 }
 
@@ -71,9 +104,9 @@ export function startEndFromNumberRanges(arrayOfNumberRanges) {
  * @return {string} - delimited number with specified decimals
  */
 export function formatNumber(
-	value,
-	{ decimals, delimits = 3, sectionDelimiter = ',', decimalDelimiter, ordinal } = {}
-) {
+	value: number | string,
+	{ decimals, delimits = 3, sectionDelimiter = ',', decimalDelimiter, ordinal }: FormatNumberOptions = {}
+): string | number {
 	if (!isNumeric(value)) return value
 	const number = Number(value)
 
@@ -108,8 +141,11 @@ export function formatNumber(
  * @param {Object} [suffixes] - list of suffixes to use for each exponent
  * @return {String} number - shorten to digits length with suffix if needed
  */
-export function shortNumber (value, digits = 3, divider = 1000, delimiter, suffixes) {
-	let number = Number(value)
+export function shortNumber (
+	value: number | string, digits = 3, divider = 1000, delimiter?: string, suffixes?: SiSuffixes
+): string {
+	// Note: `number` holds the numeric value first, then the formatted string — as it did in JS
+	let number: number | string = Number(value)
 	if (!Number.isFinite(number)) return String(number)
 	if (number === 0) return '0'
 
@@ -133,7 +169,9 @@ export function shortNumber (value, digits = 3, divider = 1000, delimiter, suffi
  * @param {Object} [suffixes] - list of suffixes to use for each exponent
  * @return {string} number - with unit suffix if needed
  */
-export function formatSI (number, precision = 3, divider = 1000, delimiter = '', suffixes = formatSI.PREFIXES) {
+export function formatSI (
+	number: number, precision = 3, divider = 1000, delimiter = '', suffixes: SiSuffixes = formatSI.PREFIXES
+): string {
 	if (!Number.isFinite(Number(number))) return String(number)
 	if (number === 0) return '0'
 
@@ -176,7 +214,7 @@ formatSI.PREFIXES = {
 	'-18': 'a',
 	'-21': 'z',
 	'-24': 'y',
-}
+} as SiSuffixes
 
 /**
  * Format Number to Ordinal Numeric String
@@ -184,14 +222,14 @@ formatSI.PREFIXES = {
  * @param {number|string} number - to format
  * @return {string} - ordered number (i.e. 1st, 2nd, 3rd, 4th...)
  */
-export function toOrdinal(number) {
-	return number + getOrdinalSuffix(number)
+export function toOrdinal(number: number | string): string {
+	return (number as string) + getOrdinalSuffix(number)
 }
 
 toOrdinal.list = ['th', 'st', 'nd', 'rd']
 
-function getOrdinalSuffix(number) {
-	const v = Math.abs(number) % 100
+function getOrdinalSuffix(number: number | string): string {
+	const v = Math.abs(number as number) % 100
 	return toOrdinal.list[(v - 20) % 10] || toOrdinal.list[v] || toOrdinal.list[0]
 }
 
@@ -201,7 +239,7 @@ function getOrdinalSuffix(number) {
  * @param {Number} degree - to ompute
  * @returns {Number} radian
  */
-export function rad(degree) {
+export function rad(degree: number): number {
 	return (degree * Math.PI) / 180
 }
 
@@ -216,7 +254,7 @@ export function rad(degree) {
  * @param {number} [precision] - decimal places to keep
  * @returns {number} - with rounded values
  */
-export function round(number, precision = 0) {
+export function round(number: number, precision = 0): number {
 	const factor = Math.pow(10, precision)
 	return Math.round(number * factor) / factor
 }
@@ -232,7 +270,7 @@ export function round(number, precision = 0) {
  * @param {number} [precision] - decimal places to keep
  * @returns {number} - with rounded values
  */
-export function roundUp(number, precision = 0) {
+export function roundUp(number: number, precision = 0): number {
 	const factor = Math.pow(10, precision)
 	return Math.ceil(number * factor) / factor
 }
@@ -248,7 +286,7 @@ export function roundUp(number, precision = 0) {
  * @param {number} [precision] - decimal places to keep
  * @returns {number} - with rounded values
  */
-export function roundDown (number, precision = 0) {
+export function roundDown (number: number, precision = 0): number {
 	const factor = Math.pow(10, precision)
 	return Math.floor(number * factor) / factor
 }
@@ -267,7 +305,7 @@ export function roundDown (number, precision = 0) {
  * @param {number} [multiple] - value, the multiple of which to round to
  * @returns {number} - rounded to given multiple of value
  */
-export function roundTo (number, multiple = 1) {
+export function roundTo (number: number, multiple = 1): number {
 	return +(Math.round(number / multiple) * multiple).toPrecision(15)
 }
 
@@ -285,7 +323,7 @@ export function roundTo (number, multiple = 1) {
  * @param {number} [multiple] - value, the multiple of which to round to
  * @returns {number} - rounded to given multiple of value
  */
-export function roundDownTo (number, multiple = 1) {
+export function roundDownTo (number: number, multiple = 1): number {
 	return +(Math.floor(+(number / multiple).toPrecision(15)) * multiple).toPrecision(15)
 }
 
@@ -301,7 +339,7 @@ export function roundDownTo (number, multiple = 1) {
  * @param {number} [multiple] - value, the multiple of which to round to
  * @returns {number} - rounded to given multiple of value
  */
-export function roundUpTo (number, multiple = 1) {
+export function roundUpTo (number: number, multiple = 1): number {
 	return +(Math.ceil(+(number / multiple).toPrecision(15)) * multiple).toPrecision(15)
 }
 
@@ -311,7 +349,7 @@ export function roundUpTo (number, multiple = 1) {
  * @param {number|string} value - number to get precision for
  * @return {number} precision - decimal places
  */
-export function decimalPlaces (value) {
+export function decimalPlaces (value: unknown): number {
 	const match = String(Number(value)).match(/(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/)
 	if (!match) return 0
 	return Math.max(
@@ -330,7 +368,7 @@ export function decimalPlaces (value) {
  * @param {Number|String} b - second number
  * @returns {Number} - the biggest divisible number between `a` and `b`
  */
-export function greatestCommonDivisor(a, b) {
+export function greatestCommonDivisor(a: number | string, b: number | string): number {
 	const first = Number(a)
 	const second = Number(b)
 	if (!Number.isFinite(first) || !Number.isFinite(second)) return Infinity
@@ -348,7 +386,7 @@ export function greatestCommonDivisor(a, b) {
  * @param {number} max - maximum number
  * @returns {number} - random value between min and max, inclusive
  */
-export function randomNumberInRange(min, max) {
+export function randomNumberInRange(min: number, max: number): number {
 	return Math.floor(Math.random() * (max - min + 1)) + min
 }
 
@@ -359,7 +397,7 @@ export function randomNumberInRange(min, max) {
  * @param {number} baseNumber - the number to calculate percentage from
  * @return {number|NaN} diff - percentage difference, or not a number
  */
-export function toPercentage(newNumber, baseNumber) {
+export function toPercentage(newNumber: unknown, baseNumber: unknown): number {
 	if (!isNumeric(newNumber) || !isNumeric(baseNumber)) return NaN
 	const newValue = Number(newNumber)
 	const baseValue = Number(baseNumber)
@@ -374,7 +412,7 @@ export function toPercentage(newNumber, baseNumber) {
  * @param {Number} [decimals] - number of digits to show after the dot
  * @returns {String} percentage - formatted string with set decimal places and '%', or empty string
  */
-export function toPercent (number, decimals = 0) {
+export function toPercent (number: unknown, decimals = 0): string {
 	if (!isNumeric(number)) return ''
 	return (Number(number) * 100).toFixed(decimals).toLocaleString() + '%'
 }
diff --git a/src/core/utils/object.js b/src/core/utils/object.ts
similarity index 69%
rename from src/core/utils/object.js
rename to src/core/utils/object.ts
index dd4f1171..0271c6b2 100644
--- a/src/core/utils/object.js
+++ b/src/core/utils/object.ts
@@ -11,21 +11,60 @@ import {
 	property,
 	setWith,
 	unset,
-} from './lodash-lite.js'
-import { isCollection } from './array.js'
+} from './lodash-lite'
+import { isCollection } from './array'
 
 /**
  * OBJECT FUNCTIONS ============================================================
  * =============================================================================
  */
 
+/**
+ * @Note on the types (§9.6-E1): these helpers walk arbitrary shapes by computed key — meta/data
+ * JSON, GraphQL responses, React state — so the types stay LOOSE on purpose. Values that are only
+ * inspected are `unknown`, a container that is handed back unchanged keeps its caller's type through
+ * a pass-through generic, and nothing accepts less at compile time than it accepts at runtime.
+ * The casts below are all of the same kind: telling the checker that a value already guarded (or
+ * simply walked) at runtime may be indexed with a computed key. They narrow nothing the runtime
+ * does not already allow.
+ */
+
+/** Anything walked with a computed key once the value is treated as object-like. */
+type Dict = Record<PropertyKey, unknown>
+
+/** The comparison modes {@link hasObjKeys} understands: 'deep', 'shallow' or 'include'. Kept a
+ *  plain `string` because an unrecognised mode is not an error at runtime — it matches everything. */
+type MatchType = string
+
+/**
+ * `setWith`'s customizer, as forwarded by {@link set}: it returns the container to create for a
+ * missing path segment.
+ * @Note: the parameters are `any` on purpose — `unknown` there would reject every caller that
+ *    annotates its own customizer, e.g. `set(obj, path, value, (v: Row) => …)`.
+ */
+type SetWithCustomizer = (nsValue: any, key: PropertyKey, nsObject: any) => unknown
+
+/** Options accepted by {@link toFlatObj}, a subset of the `flat` package's API. */
+type FlattenOpts = {
+	delimiter?: string,
+	maxDepth?: number,
+	safe?: boolean,
+}
+
+/** Options accepted by {@link fromFlatObj}, a subset of the `flat` package's API. */
+type UnflattenOpts = {
+	delimiter?: string,
+	overwrite?: boolean,
+	object?: boolean,
+}
+
 /**
  * Check if value provided is an Object with at least one attribute
  *
  * @param {*} obj - value to check
  * @returns {boolean} - true if value is an Object with value
  */
-export function hasObjectValue (obj) {
+export function hasObjectValue (obj: unknown): obj is Dict {
 	return isObject(obj) && Object.keys(obj).length > 0
 }
 
@@ -38,7 +77,7 @@ export function hasObjectValue (obj) {
  * @param {*} newVal - to compare
  * @returns {Boolean} true - if JSON string of given values are the same
  */
-export function isEqualJSON (oldVal, newVal) {
+export function isEqualJSON (oldVal: unknown, newVal: unknown): boolean {
 	return JSON.stringify(oldVal) === JSON.stringify(newVal)
 }
 
@@ -51,7 +90,7 @@ export function isEqualJSON (oldVal, newVal) {
  * @param {*} value - any value to check
  * @return {boolean}
  */
-export function isObject (value) {
+export function isObject (value: unknown): value is Dict {
 	return isPlainObject(value)
 }
 
@@ -63,7 +102,7 @@ export function isObject (value) {
  * @param {Array|Object} objects - Objects to merge
  * @return {Object} - A new object
  */
-export function merge (...objects) {
+export function merge (...objects: unknown[]): Dict {
 	return _merge({}, ...objects)
 }
 
@@ -71,8 +110,8 @@ export function merge (...objects) {
  * Like merge(), but replaces arrays wholesale instead of merging them element-by-element.
  * Prevents deleted array items from being resurrected by the base object.
  */
-export function mergeReplaceArrays (...objects) {
-	return _mergeWith({}, ...objects, (objValue, srcValue) => {
+export function mergeReplaceArrays (...objects: unknown[]): Dict {
+	return _mergeWith({}, ...objects, (objValue: unknown, srcValue: unknown) => {
 		if (Array.isArray(srcValue)) return srcValue
 	})
 }
@@ -85,7 +124,7 @@ export function mergeReplaceArrays (...objects) {
  * @param {Object|Undefined|Null} changed - object to keep changes
  * @returns {Object|Undefined|Null} changedOnly - new object with only changed values kept, or undefined if no changes
  */
-export function objChanges (original, changed) {
+export function objChanges (original?: Dict | null, changed?: Dict | null): Dict | undefined {
 	// clone so we can delete keys while iterating
 	original = {...original}
 	changed = {...changed}
@@ -95,7 +134,7 @@ export function objChanges (original, changed) {
 		} else {
 			// Recursively check for nested field changes
 			if (hasObjectValue(original[field]) && hasObjectValue(changed[field]))
-				changed[field] = objChanges(original[field], changed[field])
+				changed[field] = objChanges(original[field] as Dict, changed[field] as Dict)
 		}
 		delete original[field]
 	}
@@ -121,7 +160,7 @@ export function objChanges (original, changed) {
  * @param {Function} [customizer] - An optional function that specifies how to fill in a missing path
  * @returns {Object}
  */
-export function set(object, path, value, customizer) {
+export function set<T>(object: T, path: unknown, value: unknown, customizer?: SetWithCustomizer): T {
 	return setWith(object, path, value, customizer)
 }
 
@@ -138,17 +177,21 @@ export function set(object, path, value, customizer) {
  * @param {Boolean} [deleteNull] - whether to remove `null` props instead of updating them
  * @return {Object|Array} - mutated/cloned Object with nested update
  */
-export function update (state, payload, shouldCloneDeep = false, deleteNull = false) {
+export function update<T> (state: T, payload?: unknown, shouldCloneDeep = false, deleteNull = false): T {
 	if (shouldCloneDeep) state = cloneDeep(state)
 
-	for (const key in payload) {
-		const value = payload[key]
+	// `state` and `payload` are walked by computed key; a nullish `payload` yields no iterations,
+	// exactly as before.
+	const target = state as Dict
+	const source = payload as Dict
+	for (const key in source) {
+		const value = source[key]
 		if (value === null && deleteNull) {
-			delete state[key]
+			delete target[key]
 		} else if (isObject(value)) {
-			state[key] = state[key] ? update(state[key], value) : value
+			target[key] = target[key] ? update(target[key], value) : value
 		} else {
-			state[key] = value
+			target[key] = value
 		}
 	}
 	return state
@@ -164,11 +207,13 @@ export function update (state, payload, shouldCloneDeep = false, deleteNull = fa
  * @param {*} obj - the collection to search for matching object
  * @param {*} searchObj - the matching object to find
  * @returns {boolean} - true if a match found.
+ * @Note: the bare `return` on a non-own property yields `undefined`, not `false` — hence the
+ *    `| undefined` in the return type. Callers only ever test it for truthiness.
  */
-export function hasObjMatch(obj, searchObj) {
-	for (const key in obj) {
+export function hasObjMatch(obj: unknown, searchObj: unknown): boolean | undefined {
+	for (const key in obj as Dict) {
 		if (!{}.hasOwnProperty.call(obj, key)) return
-		const value = obj[key]
+		const value = (obj as Dict)[key]
 
 		if (matches(searchObj)(value)) {
 			return true
@@ -202,7 +247,7 @@ export function hasObjMatch(obj, searchObj) {
  *  object-like values partially by value and everything else loosely; `include` recurses to find a match.
  * @returns {boolean} - true if a match found.
  */
-export function hasObjKeys(obj, keys = {}, match = 'deep') {
+export function hasObjKeys(obj: unknown, keys: Dict = {}, match: MatchType = 'deep'): boolean | undefined {
 	for (const key in keys) {
 		const value = keys[key]
 		const searchValue = get(obj, key)
@@ -275,10 +320,10 @@ export function hasObjKeys(obj, keys = {}, match = 'deep') {
  * @param {String} match - one of comparison types ['deep', 'shallow', 'include']
  * @returns {Object} - the matching object.
  */
-export function findObjByKeys(obj, keys = {}, match = 'deep') {
-	for (const key in obj) {
+export function findObjByKeys(obj: unknown, keys: Dict = {}, match: MatchType = 'deep'): object | undefined {
+	for (const key in obj as Dict) {
 		if (!{}.hasOwnProperty.call(obj, key)) return
-		const value = obj[key]
+		const value = (obj as Dict)[key]
 
 		if (!isObjectLike(value)) continue
 
@@ -297,8 +342,8 @@ export function findObjByKeys(obj, keys = {}, match = 'deep') {
  * @param match
  * @returns {Array}
  */
-export function findAllObjsByKeys(obj, keys = {}, match = 'deep') {
-	const result = []
+export function findAllObjsByKeys(obj: unknown, keys: Dict = {}, match: MatchType = 'deep'): object[] {
+	const result: object[] = []
 	_findAllObjsByKeys(result, obj, keys, match)
 	return result
 }
@@ -314,10 +359,10 @@ export function findAllObjsByKeys(obj, keys = {}, match = 'deep') {
  * @param {Object} keys - object with key paths and values to match, e.g. { 'properties.id': 7, type: 'DRAFT' }
  * @param {String} match - one of comparison types ['deep', 'shallow', 'include']
  */
-function _findAllObjsByKeys(result, obj, keys = {}, match = 'deep') {
-	for (const key in obj) {
+function _findAllObjsByKeys(result: object[], obj: unknown, keys: Dict = {}, match: MatchType = 'deep'): void {
+	for (const key in obj as Dict) {
 		if (!{}.hasOwnProperty.call(obj, key)) return
-		const value = obj[key]
+		const value = (obj as Dict)[key]
 
 		if (!isObjectLike(value)) continue
 
@@ -330,16 +375,16 @@ function _findAllObjsByKeys(result, obj, keys = {}, match = 'deep') {
 /**
  * Flatten/Unflatten nested object keys (dot-separated). Subset of the `flat` package API.
  */
-function flattenObject (target, opts) {
+function flattenObject (target: unknown, opts?: FlattenOpts): Dict {
 	opts = opts || {}
 	const delimiter = opts.delimiter || '.'
 	const maxDepth = opts.maxDepth
-	const output = {}
-	function step (object, prev, currentDepth) {
+	const output: Dict = {}
+	function step (object: Dict, prev?: string, currentDepth?: number) {
 		currentDepth = currentDepth || 1
 		Object.keys(object).forEach(function (key) {
 			const value = object[key]
-			const isarray = opts.safe && Array.isArray(value)
+			const isarray = opts!.safe && Array.isArray(value)
 			const type = Object.prototype.toString.call(value)
 			const isbuffer = typeof Buffer !== 'undefined' && Buffer.isBuffer && Buffer.isBuffer(value)
 			const isobject = (
@@ -349,36 +394,38 @@ function flattenObject (target, opts) {
 			const newKey = prev
 				? prev + delimiter + key
 				: key
-			if (!isarray && !isbuffer && isobject && Object.keys(value).length &&
-				(!opts.maxDepth || currentDepth < maxDepth)) {
-				return step(value, newKey, currentDepth + 1)
+			if (!isarray && !isbuffer && isobject && Object.keys(value as Dict).length &&
+				(!opts!.maxDepth || currentDepth! < maxDepth!)) {
+				return step(value as Dict, newKey, currentDepth! + 1)
 			}
 			output[newKey] = value
 		})
 	}
-	step(target)
+	step(target as Dict)
 	return output
 }
 
-function unflattenObject (target, opts) {
+function unflattenObject (target: unknown, opts?: UnflattenOpts): unknown {
 	opts = opts || {}
 	const delimiter = opts.delimiter || '.'
 	const overwrite = opts.overwrite || false
-	const result = {}
+	const result: Dict = {}
 	const isbuffer = typeof Buffer !== 'undefined' && Buffer.isBuffer && Buffer.isBuffer(target)
 	if (isbuffer || Object.prototype.toString.call(target) !== '[object Object]') {
 		return target
 	}
-	function getkey (key) {
+	// `key` is `undefined` once the path is exhausted; `Number(undefined)` is NaN, so the first
+	// clause short-circuits before `.indexOf` is reached — as it always has.
+	function getkey (key: string | undefined): string | number | undefined {
 		const parsedKey = Number(key)
 		return (
 			isNaN(parsedKey) ||
-			key.indexOf('.') !== -1 ||
-			opts.object
+			key!.indexOf('.') !== -1 ||
+			opts!.object
 		) ? key
 			: parsedKey
 	}
-	const sortedKeys = Object.keys(target).sort(function (keyA, keyB) {
+	const sortedKeys = Object.keys(target as Dict).sort(function (keyA, keyB) {
 		return keyA.length - keyB.length
 	})
 	sortedKeys.forEach(function (key) {
@@ -390,27 +437,27 @@ function unflattenObject (target, opts) {
 			if (key1 === '__proto__') {
 				return
 			}
-			const type = Object.prototype.toString.call(recipient[key1])
+			const type = Object.prototype.toString.call(recipient[key1!])
 			const isobject = (
 				type === '[object Object]' ||
 				type === '[object Array]'
 			)
-			if (!overwrite && !isobject && typeof recipient[key1] !== 'undefined') {
+			if (!overwrite && !isobject && typeof recipient[key1!] !== 'undefined') {
 				return
 			}
-			if ((overwrite && !isobject) || (!overwrite && recipient[key1] == null)) {
-				recipient[key1] = (
+			if ((overwrite && !isobject) || (!overwrite && recipient[key1!] == null)) {
+				recipient[key1!] = (
 					typeof key2 === 'number' &&
-					!opts.object ? [] : {}
+					!opts!.object ? [] : {}
 				)
 			}
-			recipient = recipient[key1]
+			recipient = recipient[key1!] as Dict
 			if (split.length > 0) {
 				key1 = getkey(split.shift())
 				key2 = getkey(split[0])
 			}
 		}
-		recipient[key1] = unflattenObject(target[key], opts)
+		recipient[key1!] = unflattenObject((target as Dict)[key], opts)
 	})
 	return result
 }
@@ -429,7 +476,7 @@ export const fromFlatObj = unflattenObject
  * @param {*} [fallback] - optional fallback value to return
  * @return {*}
  */
-export function pop(obj, keyPath, fallback) {
+export function pop(obj: unknown, keyPath: unknown, fallback?: unknown): unknown {
 	const missing = {}
 	const value = get(obj, keyPath, missing)
 	if (value === missing) return fallback
@@ -444,7 +491,7 @@ export function pop(obj, keyPath, fallback) {
  * @param {string} key - Object property to delete
  * @return {Object} - without the deleted key property
  */
-export function removeKey (obj, key) {
+export function removeKey (obj: Dict, key: string): Dict {
 	const {[key]: _, ...rest} = obj // eslint-disable-line
 	return rest
 }
@@ -456,8 +503,8 @@ export function removeKey (obj, key) {
  * @param {Boolean} [clone] - whether to return new object, defaults to mutating existing
  * @param {Boolean} [recursive] - whether to parse given obj recursively
  */
-export function removeKeys (obj, keys, {clone = false, recursive = false} = {}) {
-	const data = clone ? cloneDeep(obj) : obj
+export function removeKeys<T> (obj: T, keys: readonly string[], {clone = false, recursive = false}: {clone?: boolean, recursive?: boolean} = {}): T {
+	const data = (clone ? cloneDeep(obj) : obj) as Dict
 	for (const key in data) {
 		if (keys.indexOf(key) >= 0) {
 			delete data[key]
@@ -465,7 +512,7 @@ export function removeKeys (obj, keys, {clone = false, recursive = false} = {})
 			data[key] = removeKeys(data[key], keys, {recursive})
 		}
 	}
-	return data
+	return data as T
 }
 
 /**
@@ -476,16 +523,17 @@ export function removeKeys (obj, keys, {clone = false, recursive = false} = {})
  * @param {Boolean} [recursive] - whether to remove empty values recursively
  * @return {Object|Array} - without empty strings
  */
-export function removeEmptyValues (collection, {recursive = true} = {}) {
-	for (const key in collection) {
-		if (collection[key] === '') {
-			delete collection[key]
-		} else if (recursive && typeof (collection[key] || '') === 'object') {
-			collection[key] = removeEmptyValues(collection[key], { recursive })
+export function removeEmptyValues<T> (collection: T, {recursive = true}: {recursive?: boolean} = {}): T {
+	const data = collection as Dict
+	for (const key in data) {
+		if (data[key] === '') {
+			delete data[key]
+		} else if (recursive && typeof (data[key] || '') === 'object') {
+			data[key] = removeEmptyValues(data[key], { recursive })
 		}
 	}
 
-	return collection.constructor === Array ? collection.filter(v => v) : collection
+	return (data.constructor === Array ? (data as unknown as unknown[]).filter(v => v) : data) as T
 }
 
 /**
@@ -496,16 +544,17 @@ export function removeEmptyValues (collection, {recursive = true} = {}) {
  * @param {Boolean} [recursive] - whether to remove nil values recursively
  * @return {Object|Array} - without null or undefined keys
  */
-export function removeNilValues (collection, {recursive = true} = {}) {
-	for (const key in collection) {
-		if (collection[key] == null) {
-			delete collection[key]
-		} else if (recursive && typeof collection[key] === 'object') {
-			collection[key] = removeNilValues(collection[key], {recursive})
+export function removeNilValues<T> (collection: T, {recursive = true}: {recursive?: boolean} = {}): T {
+	const data = collection as Dict
+	for (const key in data) {
+		if (data[key] == null) {
+			delete data[key]
+		} else if (recursive && typeof data[key] === 'object') {
+			data[key] = removeNilValues(data[key], {recursive})
 		}
 	}
 
-	return collection.constructor === Array ? collection.filter(v => v) : collection
+	return (data.constructor === Array ? (data as unknown as unknown[]).filter(v => v) : data) as T
 }
 
 /**
@@ -515,19 +564,20 @@ export function removeNilValues (collection, {recursive = true} = {}) {
  * @param {Object|Array} collection - to remove deleted items from
  * @return {Object|Array} - without items with .delete keys
  */
-export function removeDeletedItems(collection) {
-	for (const key in collection) {
+export function removeDeletedItems<T>(collection: T): T {
+	const data = collection as Dict
+	for (const key in data) {
 		// Null is of type 'object' according to stupid JS specs
-		if (typeof (collection[key] || '') !== 'object') continue
+		if (typeof (data[key] || '') !== 'object') continue
 
-		if (collection[key].delete) {
-			delete collection[key]
+		if ((data[key] as Dict).delete) {
+			delete data[key]
 		} else {
-			collection[key] = removeDeletedItems(collection[key])
+			data[key] = removeDeletedItems(data[key])
 		}
 	}
 
-	return collection.constructor === Array ? collection.filter(v => v) : collection
+	return (data.constructor === Array ? (data as unknown as unknown[]).filter(v => v) : data) as T
 }
 
 /**
@@ -540,8 +590,8 @@ export function removeDeletedItems(collection) {
  * @param {Boolean} [clone] - whether to clone the object before mutating
  * @return {Object|Array} - without graphql tags
  */
-export function sanitizeResponse (collection, {tags = ['__typename'], clone = false} = {}) {
-	const result = clone ? cloneDeep(collection) : collection
+export function sanitizeResponse<T> (collection: T, {tags = ['__typename'], clone = false}: {tags?: readonly string[], clone?: boolean} = {}): T {
+	const result = (clone ? cloneDeep(collection) : collection) as Dict
 
 	for (const key in result) {
 		if (tags.includes(key)) {
@@ -553,7 +603,7 @@ export function sanitizeResponse (collection, {tags = ['__typename'], clone = fa
 		}
 	}
 
-	return result.constructor === Array ? result.filter(v => v != null) : result
+	return (result.constructor === Array ? (result as unknown as unknown[]).filter(v => v != null) : result) as T
 }
 
 /**
@@ -563,8 +613,8 @@ export function sanitizeResponse (collection, {tags = ['__typename'], clone = fa
  * @param {String} order - enum, one of ['asc', 'desc']
  * @return {Object} - sorted by key attributes
  */
-export function sortObjKeys(obj, order = 'asc') {
-	const result = {}
+export function sortObjKeys(obj: Dict, order: string = 'asc'): Dict {
+	const result: Dict = {}
 	Object.keys(obj)
 		.sort(order === 'desc' ? sortObjKeys.descending : undefined)
 		.forEach(key => {
@@ -573,7 +623,7 @@ export function sortObjKeys(obj, order = 'asc') {
 	return result
 }
 
-sortObjKeys.descending = (a, b) => {
+sortObjKeys.descending = (a: string, b: string): number => {
 	if (a < b) return 1
 	if (a > b) return -1
 	return 0
@@ -589,10 +639,11 @@ sortObjKeys.descending = (a, b) => {
  * @param {Object} obj - to swap keys with values
  * @returns {Object} - with key and values swapped
  */
-export function swapKeyWithValue(obj) {
-	const result = {}
+export function swapKeyWithValue(obj: Dict): Dict {
+	const result: Dict = {}
 	for (const key in obj) {
-		result[obj[key]] = key
+		// the value becomes a key: at runtime JS coerces whatever it is to a property key
+		result[obj[key] as PropertyKey] = key
 	}
 	return result
 }
@@ -606,10 +657,10 @@ export function swapKeyWithValue(obj) {
  * @param {Object} obj - with nested values to calculate total for
  * @returns {number} total - value of object values
  */
-export function toObjValuesTotal(obj) {
+export function toObjValuesTotal(obj: Dict): number {
 	let sum = 0
 	for (const key in obj) {
-		sum += obj[key]
+		sum += obj[key] as number
 	}
 	return sum
 }
diff --git a/src/core/utils/selectors.js b/src/core/utils/selectors.ts
similarity index 100%
rename from src/core/utils/selectors.js
rename to src/core/utils/selectors.ts
diff --git a/src/core/utils/storage.js b/src/core/utils/storage.ts
similarity index 51%
rename from src/core/utils/storage.js
rename to src/core/utils/storage.ts
index 7e55e4c9..a4ebedc2 100644
--- a/src/core/utils/storage.js
+++ b/src/core/utils/storage.ts
@@ -1,15 +1,30 @@
-import { Active } from './_envs.js'
-import { isList } from './array.js'
-import { fromJSON, toJSON } from './codec.js'
-import { ADD, DELETE, GET, SET } from './constants.js'
-import { enumCheck } from './function.js'
-import { update } from './object.js'
+import { Active } from './_envs'
+import { isList } from './array'
+import { fromJSON, toJSON } from './codec'
+import { ADD, DELETE, GET, SET } from './constants'
+import { enumCheck } from './function'
+import { update } from './object'
 
 /**
  * STORAGE FUNCTIONS ===========================================================
  * =============================================================================
  */
 
+/** Every action `performStorage` understands */
+export type StorageAction = typeof GET | typeof SET | typeof DELETE | typeof ADD
+
+/** Actions dispatched straight to a storage backend (`ADD` is an abstraction over `GET` + `SET`) */
+export type StorageActionDirect = typeof GET | typeof SET | typeof DELETE
+
+/** Mapping of a direct action to the backend method name that performs it */
+export type StorageMethods = Record<StorageActionDirect, string>
+
+/**
+ * Backend storage adapter injected as `Active.Storage` (async or sync implementation).
+ * @note: methods are looked up by name at runtime, hence the index signature.
+ */
+export type StorageAdapter = Record<string, (...args: unknown[]) => unknown>
+
 const hasLocalStorage = typeof localStorage !== 'undefined'  // eslint-disable-line
 
 /**
@@ -28,11 +43,13 @@ const hasLocalStorage = typeof localStorage !== 'undefined'  // eslint-disable-l
  * @param {Array|Object} initialValue - used for ADD ACTION when saving the first time
  * @return {*} - Synchronous/Asynchronous promise result of Local Storage (or stored value for GET action)
  */
-export function performStorage (ACTION, storageKey, value = null, initialValue = []) {
+export function performStorage (
+  this: unknown, ACTION: StorageAction, storageKey: string, value: unknown = null, initialValue: unknown = [],
+): unknown {
   /* ADD action abstraction */
   if (ACTION === ADD) {
     if (performStorage.isAsync) {
-      return performStorage(GET, storageKey)
+      return (performStorage(GET, storageKey) as Promise<unknown>)
         .then(value => value || initialValue)
         .then(oldData => performStorage(SET, storageKey, isList(oldData) ? oldData.concat(value) : update(oldData, value)))
     }
@@ -43,12 +60,12 @@ export function performStorage (ACTION, storageKey, value = null, initialValue =
   enumCheck([GET, SET, DELETE], ACTION, this)
 
   /* SERVER (or missing localStorage) */
-  if (!hasLocalStorage) return Active.Storage[performStorage.toServer[ACTION]](storageKey, value)
+  if (!hasLocalStorage) return (Active.Storage as StorageAdapter)[performStorage.toServer[ACTION]](storageKey, value)
 
   /* CLIENT */
-  const args = [storageKey]
+  const args: unknown[] = [storageKey]
   if (SET === ACTION) args.push(toJSON(value))
-  let result = localStorage[performStorage.toClient[ACTION]](...args)
+  let result: unknown = localStorage[performStorage.toClient[ACTION]](...args)
 
   // Storage Retrieval
   if (GET === ACTION && result) result = fromJSON(result)  // Deserialize data
@@ -56,6 +73,17 @@ export function performStorage (ACTION, storageKey, value = null, initialValue =
   return result
 }
 
+export declare namespace performStorage {
+  /** `true` once an asynchronous backend was wired up with `performStorage.init()` */
+  let isAsync: boolean | undefined
+  /** Browser `localStorage` method names */
+  let toClient: StorageMethods
+  /** Currently active `Active.Storage` method names (asynchronous by default) */
+  let toServer: StorageMethods
+  /** Synchronous `Active.Storage` method names */
+  let toServerSync: StorageMethods
+}
+
 performStorage.toClient = {
   [GET]: 'getItem',
   [SET]: 'setItem',
@@ -72,14 +100,14 @@ performStorage.toServerSync = {
   [DELETE]: 'removeItemSync'
 }
 // Setup Asynchronous Local Storage
-performStorage.init = function (...args) {
+performStorage.init = function (...args: unknown[]): unknown {
   performStorage.isAsync = true
   performStorage.toServer = toServerAsync
-  return Active.Storage.init(...args)
+  return (Active.Storage as StorageAdapter).init(...args)
 }
 // Setup Synchronous Local Storage (not recommended)
-performStorage.initSync = function (...args) {
+performStorage.initSync = function (...args: unknown[]): unknown {
   performStorage.isAsync = false
   performStorage.toServer = performStorage.toServerSync
-  return Active.Storage.initSync(...args)
+  return (Active.Storage as StorageAdapter).initSync(...args)
 }
diff --git a/src/core/utils/string.js b/src/core/utils/string.ts
similarity index 75%
rename from src/core/utils/string.js
rename to src/core/utils/string.ts
index 2e3e6100..10ce3359 100644
--- a/src/core/utils/string.js
+++ b/src/core/utils/string.ts
@@ -1,4 +1,4 @@
-import { capitalize, get } from './lodash-lite.js'
+import { capitalize, get } from './lodash-lite'
 
 export const alphaNumPattern = /[^a-zA-Z0-9]/g
 export const alphaNumIdPattern = /[^a-zA-Z0-9_-]/g
@@ -15,6 +15,26 @@ const symbolRatio = symbols.length / (62 + symbols.length) // rate of symbols ag
 const upperThreshold = 1 - 26 / (62 + symbols.length) // minimum Math.random() result for upper case
 const upperThresholdAlphaNum = 1 - 26 / 62 // minimum Math.random() result for upper case
 
+/**
+ * Options accepted by {@link interpolateString}.
+ */
+export type InterpolateStringOptions = {
+	/** key format to match in given 'variables' (e.g. format = '$key') */
+	formatKey?: string,
+	/** function name to use in case error is thrown */
+	name?: string,
+	/** whether to ignore error when replacement string not found, and leave as is */
+	suppressError?: boolean,
+}
+
+/** Options accepted by {@link randomString}. */
+export type RandomStringOptions = {
+	/** whether to create alphanumeric string only */
+	alphaNum?: boolean,
+	/** whether to create hex string only */
+	hex?: boolean,
+}
+
 /**
  * STRING FUNCTIONS ===========================================================
  * =============================================================================
@@ -27,18 +47,20 @@ const upperThresholdAlphaNum = 1 - 26 / 62 // minimum Math.random() result for u
  * @param {string} search - needle
  * @return {boolean}
  */
-export function isInString(string, search) {
+export function isInString(string: string, search: string): boolean {
 	return string.indexOf(search) > -1
 }
 
 /**
  * Checks to see if any of the searches params exist within the string param.
  *
+ * @note: the haystack is deliberately `unknown` - callers pass null/undefined/numbers,
+ *        which the runtime guard below rejects with `false`.
  * @param {string} string - haystack
  * @param searches - needles
  * @return {boolean}
  */
-export function isInStringAny(string, ...searches) {
+export function isInStringAny(string: unknown, ...searches: string[]): boolean {
 	if (typeof string !== 'string') return false
 
 	for (const value of searches) {
@@ -56,7 +78,7 @@ export function isInStringAny(string, ...searches) {
  * @param {string|number} value - the string to insert
  * @returns {string}
  */
-export function insertToString (string, index, value) {
+export function insertToString (string: string, index: number, value: string | number): string {
 	if (index > 0) return string.substring(0, index) + value + string.substring(index, string.length)
 	return value + string
 }
@@ -67,17 +89,19 @@ export function insertToString (string, index, value) {
  * @param {String} string - value to check
  * @returns {Boolean} true - if it is a valid Base64 encoded string
  */
-export function isBase64 (string) {
+export function isBase64 (string: string): boolean {
 	return isBase64Pattern.test(string)
 }
 
 /**
  * Check if given string is a File URL or Path.
  * Helps to determine if File.src is URL or Path string vs. base64 encoded string.
+ * @note: boxed `String` objects reach this function in practice (see components/utils/img.js),
+ *        hence the wider parameter type.
  * @param {String} string - to check
  * @returns {Boolean} true - if string contains a dot '.', because a file always needs extension
  */
-export function isFileSrc (string) {
+export function isFileSrc (string: string | String | null | undefined): boolean {
 	return !!string && string.indexOf('.') > -1
 }
 
@@ -86,7 +110,7 @@ export function isFileSrc (string) {
  * @param {*} value - to check
  * @returns {Boolean} true - if it's a string
  */
-export function isString(value) {
+export function isString(value: unknown): value is string {
 	return typeof value === 'string'
 }
 
@@ -112,19 +136,26 @@ export function isString(value) {
  * @param {Boolean} [suppressError] - whether to ignore error when replacement string not found, and leave as is
  * @return {String} output - with interpolated variables
  */
-export function interpolateString (string, variables = {}, {formatKey, name, suppressError} = {}) {
-	return string.replace(interpolateStringPattern, (__, match) => {
+export function interpolateString (
+	string: string,
+	variables: Record<string, unknown> = {},
+	{formatKey, name, suppressError}: InterpolateStringOptions = {},
+): string {
+	return string.replace(interpolateStringPattern, (__: string, match: string) => {
 		let key = match
 		if (formatKey) key = formatKey.replace('key', key)
 		// noinspection JSCheckFunctionSignatures
-		const result = get(variables, ...key.split(','))
+		// @Note: `get` takes (object, path, defaultValue) - the split yields the path, plus an
+		// optional fallback. Extra comma separated parts are ignored by `get`, as before.
+		const result = get(variables, ...(key.split(',') as [string, string?]))
 		if (result === void 0) {
 			if (!suppressError && !variables.hasOwnProperty(key.split(',')[0])) {
 				throw new Error(`${name || interpolateString.name + '()'} expects variable '${key}', got '${variables[key]}'`)
 			}
 			return `{${match}}`
 		}
-		return result
+		// @Note: non-string values (numbers, booleans) are returned as is and coerced by `replace`
+		return result as string
 	})
 }
 
@@ -139,9 +170,11 @@ export const interpolateStringPattern = /{([^{}]+)}/g
  *
  * @param {string} keyPath - the path string to format
  */
-export function formatKeyPath(keyPath) {
+export function formatKeyPath(keyPath: string): string {
 	return keyPath.replace(
-		formatKeyPathPattern, (match, match1, match2, match3, offset) => (offset > 0 ? '.' : '') + String(match2)
+		formatKeyPathPattern,
+		(match: string, match1: string, match2: string, match3: string, offset: number) =>
+			(offset > 0 ? '.' : '') + String(match2),
 	)
 }
 
@@ -153,9 +186,9 @@ export const formatKeyPathPattern = /(\[)(.*?)(\])/g
  * @param {string} fileName - full file name with format extension (ex. 'image.png')
  * @returns {string} extension - file format if exists (ex. 'png') or empty string if it does not
  */
-export function fileFormat (fileName) {
+export function fileFormat (fileName: string): string {
 	const array = fileName.split('.')
-	return array.length > 1 ? array.pop() : ''
+	return array.length > 1 ? array.pop() as string : ''
 }
 
 /**
@@ -164,7 +197,7 @@ export function fileFormat (fileName) {
  * @param {String|Null|Undefined} fileName - to extract extension
  * @returns {String|Undefined} file format extension, or empty string, or undefined
  */
-export function fileFormatNormalized (fileName) {
+export function fileFormatNormalized (fileName: string | null | undefined): string | undefined {
 	if (!fileName) return
 	const ext = fileFormat(toLowerCase(fileName))
 	switch (ext) {
@@ -181,7 +214,7 @@ export function fileFormatNormalized (fileName) {
  *
  * @param {string} fileName - full file name with extension
  */
-export function fileNameWithoutExt (fileName) {
+export function fileNameWithoutExt (fileName: string): string {
 	return fileName.replace(fileNameWithoutExtPattern, '')
 }
 
@@ -191,9 +224,9 @@ export function fileNameWithoutExt (fileName) {
  * @param {String} filename
  * @returns {File} file - object
  */
-export function fileFromDataUrl (dataUrl, filename) {
+export function fileFromDataUrl (dataUrl: string, filename: string): File {
 	const arr = dataUrl.split(',')
-	const mime = arr[0].match(/:(.*?);/)[1]
+	const mime = (arr[0].match(/:(.*?);/) as RegExpMatchArray)[1]
 	const str = atob(arr[1])
 	let n = str.length
 	const u8arr = new Uint8Array(n)
@@ -210,8 +243,8 @@ export function fileFromDataUrl (dataUrl, filename) {
  * @param {String} dataUrl - see https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs
  * @returns {String|undefined} mime type
  */
-export function mimeTypeFromDataUrl (dataUrl) {
-	return dataUrl.split(',')[0].match(/:(.*?);/)[1]
+export function mimeTypeFromDataUrl (dataUrl: string): string {
+	return (dataUrl.split(',')[0].match(/:(.*?);/) as RegExpMatchArray)[1]
 }
 
 /**
@@ -220,8 +253,8 @@ export function mimeTypeFromDataUrl (dataUrl) {
  * @param {string} url - to extract hostname
  * @return {string} - hostname
  */
-export function hostname (url) {
-	let hostname
+export function hostname (url: string): string {
+	let hostname: string
 
 	// find & remove protocol (http, ftp, etc.) and get hostname
 	if (url.indexOf('://') > -1) {
@@ -251,8 +284,8 @@ export function hostname (url) {
  * @param {string} after - string succeeding the match
  * @returns {string} - matching string between `before` and `after` strings if found, or an empty string if not
  */
-export function matchBetween(string, before, after) {
-	return get(string.match(`${before}(.*)${after}`), '[1]') || ''
+export function matchBetween(string: string, before: string, after: string): string {
+	return (get(string.match(`${before}(.*)${after}`), '[1]') as string | undefined) || ''
 }
 
 /**
@@ -262,7 +295,7 @@ export function matchBetween(string, before, after) {
  * @param {string|number} str2
  * @returns {string} - scrambled characters from provided values
  */
-export function mergeStrings(str1, str2) {
+export function mergeStrings(str1: string | number, str2: string | number): string {
 	str1 = String(str1)
 	str2 = String(str2)
 	const isFirstLong = str1.length >= str2.length
@@ -283,7 +316,7 @@ export function mergeStrings(str1, str2) {
  * @param {String} padTemplate - example: '000'
  * @return {String} padded with template - example: '007'
  */
-export function padStringLeft (string, padTemplate) {
+export function padStringLeft (string: string, padTemplate: string): string {
 	return `${padTemplate}${string}`.slice(-(Math.max(string.length, padTemplate.length)))
 }
 
@@ -294,7 +327,7 @@ export function padStringLeft (string, padTemplate) {
  * @param {String} padTemplate - example: '000'
  * @return {String} padded with template - example: '700'
  */
-export function padStringRight (string, padTemplate) {
+export function padStringRight (string: string, padTemplate: string): string {
 	return `${string}${padTemplate}`.substr(0, Math.max(string.length, padTemplate.length))
 }
 
@@ -307,30 +340,30 @@ export function padStringRight (string, padTemplate) {
  * @param {boolean} [shouldIncludeCount] - If true, prefix the result with the count
  * @return {string} - A new string
  */
-export function pluralize(word, count, shouldIncludeCount) {
+export function pluralize(word: string, count?: number | null, shouldIncludeCount?: boolean): string {
 	const n = count == null ? 2 : count
 	const result = Math.abs(n) === 1 ? toSingular(word) : toPlural(word)
 	return shouldIncludeCount ? `${n} ${result}` : result
 }
 
-const irregularPluralByForms = {
+const irregularPluralByForms: Record<string, string> = {
 	man: 'men', woman: 'women', child: 'children', tooth: 'teeth', foot: 'feet',
 	mouse: 'mice', person: 'people', goose: 'geese', ox: 'oxen',
 }
-const irregularSingularByForms = Object.fromEntries(
+const irregularSingularByForms: Record<string, string> = Object.fromEntries(
 	Object.entries(irregularPluralByForms).map(([s, p]) => [p, s])
 )
 const uncountable = new Set([
 	'sheep', 'fish', 'series', 'species', 'deer', 'information', 'equipment', 'rice', 'money',
 ])
 
-function preserveCase(source, target) {
+function preserveCase(source: string, target: string): string {
 	if (source === source.toUpperCase()) return target.toUpperCase()
 	if (source[0] === source[0].toUpperCase()) return target[0].toUpperCase() + target.slice(1)
 	return target
 }
 
-function toPlural(word) {
+function toPlural(word: string): string {
 	const lower = word.toLowerCase()
 	if (uncountable.has(lower)) return word
 	if (irregularPluralByForms[lower]) return preserveCase(word, irregularPluralByForms[lower])
@@ -340,7 +373,7 @@ function toPlural(word) {
 	return word + 's'
 }
 
-function toSingular(word) {
+function toSingular(word: string): string {
 	const lower = word.toLowerCase()
 	if (uncountable.has(lower)) return word
 	if (irregularSingularByForms[lower]) return preserveCase(word, irregularSingularByForms[lower])
@@ -357,7 +390,7 @@ function toSingular(word) {
  * @param {String} string
  * @returns {String} character
  */
-export function randomFromString(string) {
+export function randomFromString(string: string): string {
 	return string.charAt(Math.floor(Math.random() * string.length))
 }
 
@@ -370,7 +403,7 @@ export function randomFromString(string) {
  * @param {Boolean} [hex] - whether to create hex string only
  * @returns {String} random - ASCII compliant string
  */
-export function randomString (min = 32, max = 64, {alphaNum = false, hex = false} = {}) {
+export function randomString (min = 32, max = 64, {alphaNum = false, hex = false}: RandomStringOptions = {}): string {
 	const searchSpace = hex ? 16 : 36
 	const uppercase = alphaNum ? upperThresholdAlphaNum : upperThreshold
 	return [...Array(randomNumberInRange(min, max))]
@@ -383,7 +416,10 @@ export function randomString (min = 32, max = 64, {alphaNum = false, hex = false
 		.join('')
 }
 
-randomString.history = []
+randomString.history = [] as unknown[]
+
+/** Memoised round constants and initial hash values, cached on the `sha256` function itself. */
+type Sha256Cache = {h?: number[], k?: number[]}
 
 /**
  * Hash ASCII String using SHA256
@@ -391,33 +427,37 @@ randomString.history = []
  * @param {String} ascii - compliant
  * @returns {String} digest - hashed to 64 characters long
  */
-export function sha256(ascii) {
-	function rightRotate(value, amount) {
+export function sha256(ascii: string): string | undefined {
+	function rightRotate(value: number, amount: number): number {
 		return (value >>> amount) | (value << (32 - amount))
 	}
 
 	const mathPow = Math.pow
 	const maxWord = mathPow(2, 32)
 	const lengthProperty = 'length'
-	let i, j // Used as a counter across the whole file
+	let i: number, j: number // Used as a counter across the whole file
 	let result = ''
 
-	const words = []
+	const words: number[] = []
 	const asciiBitLength = ascii[lengthProperty] * 8
 
+	// @Note: the cache below lives on the function object itself, exactly as before - the alias
+	// only gives the expando properties a type.
+	const cache = sha256 as typeof sha256 & Sha256Cache
+
 	//* caching results is optional - remove/add slash from front of this line to toggle
 	// Initial hash value: first 32 bits of the fractional parts of the square roots of the first 8 primes
 	// (we actually calculate the first 64, but extra values are just ignored)
-	let hash = (sha256.h = sha256.h || [])
+	let hash: number[] = (cache.h = cache.h || [])
 	// Round constants: first 32 bits of the fractional parts of the cube roots of the first 64 primes
-	const k = (sha256.k = sha256.k || [])
+	const k: number[] = (cache.k = cache.k || [])
 	let primeCounter = k[lengthProperty]
 	/*/
   const hash = [], k = [];
   const primeCounter = 0;
   //*/
 
-	const isComposite = {}
+	const isComposite: Record<number, number> = {}
 	for (let candidate = 2; primeCounter < 64; candidate++) {
 		if (!isComposite[candidate]) {
 			for (i = 0; i < 313; i += candidate) {
@@ -498,8 +538,8 @@ export function sha256(ascii) {
  * @param {String} string - to encode
  * @returns {String} hex - encoded string
  */
-export function toHex(string) {
-	let hex
+export function toHex(string: string): string {
+	let hex: string
 	let result = ''
 	for (let i = 0; i < string.length; i++) {
 		hex = string.charCodeAt(i).toString(16)
@@ -514,7 +554,7 @@ export function toHex(string) {
  * @param {String} string - to convert
  * @returns {String} - with alpha numeric characters only
  */
-export function toAlphaNum(string) {
+export function toAlphaNum(string: string): string {
 	return string.replace(alphaNumPattern, '')
 }
 
@@ -524,7 +564,7 @@ export function toAlphaNum(string) {
  * @param {String} string - to convert
  * @returns {String} - with alpha numeric characters, dash and underscore only
  */
-export function toAlphaNumId(string) {
+export function toAlphaNumId(string: string): string {
 	return string.replace(alphaNumIdPattern, '')
 }
 
@@ -533,7 +573,7 @@ export function toAlphaNumId(string) {
  * @param {String} string - to sanitize, can contain any characters
  * @returns {String} URI - sanitized for browser URL, without encoding/decoding
  */
-export function toURI (string) {
+export function toURI (string: string): string {
 	return string && string.replace(spacesPattern, '-') // remove spaces/newlines before stripping special characters
 		.replace(alphaNumIdPattern, '-') // convert all invalid characters to hyphen
 		.replace(hyphensPattern, '-') // may have hyphen at the start or end
@@ -549,7 +589,7 @@ export function toURI (string) {
  * @param {Number} [lastChars] - number of characters to keep at the end
  * @returns {String} string - truncated to given total length
  */
-export function truncate(string, length = 15, lastChars = 3) {
+export function truncate(string: string, length = 15, lastChars = 3): string {
 	if (string.length <= length) return string
 	const firstChars = length - lastChars - 3
 	if (firstChars < 1) return string
@@ -558,11 +598,14 @@ export function truncate(string, length = 15, lastChars = 3) {
 
 /**
  * Convert All Characters to lower case
+ * @note: falsy values (null, undefined, '', 0, false) are returned untouched, as at runtime.
  * @param {String|*} string - value to make lower case
  * @returns {String|*} - in lower case
  */
-export function toLowerCase (string) {
-	return string && string.toLowerCase()
+export function toLowerCase (string: string): string
+export function toLowerCase <T>(string: T): T
+export function toLowerCase (string: unknown): unknown {
+	return (string as string) && (string as string).toLowerCase()
 }
 
 /**
@@ -570,17 +613,20 @@ export function toLowerCase (string) {
  * @param {*} value - make lower case
  * @returns {String} value - in lower case
  */
-export function toLowerCaseAny (value) {
+export function toLowerCaseAny (value: unknown): string {
 	return String(value).toLowerCase()
 }
 
 /**
  * Convert All Characters to UPPER CASE
+ * @note: falsy values (null, undefined, '', 0, false) are returned untouched, as at runtime.
  * @param {String|*} string - value to make upper case
  * @returns {String|*} - in upper case
  */
-export function toUpperCase (string) {
-	return string && string.toUpperCase()
+export function toUpperCase (string: string): string
+export function toUpperCase <T>(string: T): T
+export function toUpperCase (string: unknown): unknown {
+	return (string as string) && (string as string).toUpperCase()
 }
 
 /**
@@ -588,18 +634,21 @@ export function toUpperCase (string) {
  * @param {*} value - make UPPER CASE
  * @returns {String} value - in UPPER CASE
  */
-export function toUpperCaseAny (value) {
+export function toUpperCaseAny (value: unknown): string {
 	return String(value).toUpperCase()
 }
 
 /**
  * Trim spaces at the start and end of String, and convert multiples spaces,
  * including tabs, newline, etc. in between to a single space.
+ * @note: falsy values (null, undefined, '', 0, false) are returned untouched, as at runtime.
  * @param {String|*} string - to trim
  * @returns {String|*} string - trimmed
  */
-export function trimSpaces (string) {
-	return string && string.replace(spacesPattern, ' ').trim()
+export function trimSpaces (string: string): string
+export function trimSpaces <T>(string: T): T
+export function trimSpaces (string: unknown): unknown {
+	return (string as string) && (string as string).replace(spacesPattern, ' ').trim()
 }
 
 /**
@@ -608,7 +657,7 @@ export function trimSpaces (string) {
  * @see: https://stackoverflow.com/questions/105034/create-guid-uuid-in-javascript
  * @returns {String} uuid - in this format 'xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx'
  */
-export function uuid () {
+export function uuid (): string {
 	const d0 = (Math.random() * 0xffffffff) | 0
 	const d1 = (Math.random() * 0xffffffff) | 0
 	const d2 = (Math.random() * 0xffffffff) | 0
@@ -637,7 +686,7 @@ export function uuid () {
 	)
 }
 
-const lut = []
+const lut: string[] = []
 for (let i = 0; i < 256; i++) {
 	lut[i] = (i < 16 ? '0' : '') + i.toString(16)
 }
@@ -658,6 +707,6 @@ export {
 		capitalize,
 }
 
-function randomNumberInRange (min, max) {
+function randomNumberInRange (min: number, max: number): number {
 	return Math.floor(Math.random() * (max - min + 1)) + min
 }
diff --git a/src/core/utils/time.js b/src/core/utils/time.ts
similarity index 61%
rename from src/core/utils/time.js
rename to src/core/utils/time.ts
index 5b569f02..d02ba823 100644
--- a/src/core/utils/time.js
+++ b/src/core/utils/time.ts
@@ -3,7 +3,14 @@
  * =============================================================================
  */
 
-const UNITS = [
+interface UnitDefinition {
+  unit: string
+  /** [singular, plural] */
+  long: [string, string]
+  ms: number
+}
+
+const UNITS: UnitDefinition[] = [
   { unit: 'y', long: ['year', 'years'], ms: 31557600000 },
   { unit: 'mo', long: ['month', 'months'], ms: 2629800000 },
   { unit: 'w', long: ['week', 'weeks'], ms: 604800000 },
@@ -14,33 +21,45 @@ const UNITS = [
   { unit: 'ms', long: ['millisecond', 'milliseconds'], ms: 1 },
 ]
 
+export interface FormatDurationOptions {
+  /** whether to use short unit forms (y/mo/w/d/h/m/s/ms) */
+  shorten?: boolean
+  /** whether to round the smallest unit (default true) */
+  round?: boolean
+  /** render at most N largest non-zero units */
+  largest?: number | null
+  /** separator between units (default ', ') */
+  delimiter?: string
+  /** separator between value and unit (default ' ') */
+  spacer?: string
+  /** decimal separator for fractional values (default '.') */
+  decimal?: string
+}
+
 /**
  * Convert Time Duration to User Friendly and Readable Format
  *
- * @param {Number} milliseconds - duration in milliseconds to convert
- * @param {Object} [options]
- * @param {Boolean} [options.shorten] - whether to use short unit forms (y/mo/w/d/h/m/s/ms)
- * @param {Boolean} [options.round=true] - whether to round the smallest unit
- * @param {Number} [options.largest] - render at most N largest non-zero units
- * @param {String} [options.delimiter=', '] - separator between units
- * @param {String} [options.spacer=' '] - separator between value and unit
- * @param {String} [options.decimal='.'] - decimal separator for fractional values
- * @returns {String} - formatted time
+ * `milliseconds` is passed through `Number()`, so the public API also accepts
+ * numeric strings, `null` and `undefined` — anything non-finite formats as zero.
+ *
+ * @param milliseconds - duration in milliseconds to convert
+ * @param options
+ * @returns formatted time
  */
-export function formatDuration (milliseconds, {
+export function formatDuration (milliseconds: unknown, {
   shorten = false,
   round = true,
   largest,
   delimiter = ', ',
   spacer = ' ',
   decimal = '.',
-} = {}) {
+}: FormatDurationOptions = {}): string {
   const duration = Number(milliseconds)
   if (!Number.isFinite(duration) || duration === 0) {
     return shorten ? `0${spacer}s` : `0${spacer}seconds`
   }
   let remaining = Math.abs(duration)
-  const parts = []
+  const parts: string[] = []
   for (let i = 0; i < UNITS.length; i++) {
     const def = UNITS[i]
     const isLast = i === UNITS.length - 1
@@ -65,6 +84,9 @@ export function formatDuration (milliseconds, {
   return sign + parts.join(delimiter)
 }
 
-formatDuration.shortEnglish = function (milliseconds, options = {}) {
+formatDuration.shortEnglish = function (
+  milliseconds: unknown,
+  options: FormatDurationOptions | null | undefined = {},
+): string {
   return formatDuration(milliseconds, { ...options, shorten: true })
 }
diff --git a/src/core/utils/translations.js b/src/core/utils/translations.ts
similarity index 88%
rename from src/core/utils/translations.js
rename to src/core/utils/translations.ts
index ac8c2144..ca3b9f79 100644
--- a/src/core/utils/translations.js
+++ b/src/core/utils/translations.ts
@@ -1,11 +1,15 @@
 import { l } from './constants'
 import { localiseTranslation } from './definitions'
+import type { Translation } from './definitions'
 
 /**
  * LOCALISED TRANSLATIONS (i18n) ===============================================
  * =============================================================================
  */
 
+/** Every phrase reads back as a localised `string`; an unknown phrase reads back as 'Untranslated' */
+export type LocalisedStrings = Record<string, string>
+
 /**
  * Localised String Object (can be extended by adding new terms or languages)
  * @note: follow the example to ensure only one instance of translation exists.
@@ -22,13 +26,15 @@ import { localiseTranslation } from './definitions'
  *    >>> 'New Phrase'
  *    console.log(_.THANK_YOU)
  *    >>> 'Thank You!'
- * @returns {Object} localised string - that returns localised 'Untranslated' string if no translation found
+ * @returns localised string - that returns localised 'Untranslated' string if no translation found
  */
 export const _ = new Proxy(localiseTranslation.instance, {
   get (target, prop) {
-    return localiseTranslation.queriedById[prop] = (target[prop] || target.UNTRANSLATED)
+    // @Note: a symbol `prop`, or one with no translation, reads back as `undefined` and falls back
+    const slots = target as Record<PropertyKey, string | Translation | undefined>
+    return localiseTranslation.queriedById[prop] = (slots[prop] || target.UNTRANSLATED)
   }
-})
+}) as LocalisedStrings
 localiseTranslation({
   // Default messaged for undefined strings
   UNTRANSLATED: {
diff --git a/src/core/utils/utility.js b/src/core/utils/utility.ts
similarity index 60%
rename from src/core/utils/utility.js
rename to src/core/utils/utility.ts
index fa9ce6af..6667b75e 100644
--- a/src/core/utils/utility.js
+++ b/src/core/utils/utility.ts
@@ -1,14 +1,23 @@
-import { Active } from './_envs.js'
-import { isInList, isList } from './array.js'
-import { rad } from './number.js'
-import { isObject } from './object.js'
-import { isString, padStringLeft, randomString } from './string.js'
+import { Active } from './_envs'
+import { isInList, isList } from './array'
+import { rad } from './number'
+import { isObject } from './object'
+import { isString, padStringLeft, randomString } from './string'
 
 /**
  * AD HOC FUNCTIONS ============================================================
  * =============================================================================
  */
 
+/** Options accepted by the `Id()` generator (all optional, see `Id` for defaults) */
+export interface IdOptions {
+  timestamp?: number
+  caseSensitive?: boolean
+  alphabet?: string
+  padCount?: number
+  suffix?: string
+}
+
 /**
  * Create Case-Sensitive Short Auto Incrementing ID string derived from Timestamp in milliseconds
  * @Important:
@@ -34,12 +43,12 @@ import { isString, padStringLeft, randomString } from './string.js'
  *    - Collision from the same user is prevented by checking for suffix duplicates within each millisecond.
  *    - This function is purposely slow with de-optimization to prevent generating too many Ids within one millisecond.
  *
- * @param {Number|String} [timestamp] - custom timestamp to generate ID for, defaults to Date.now()
- * @param {String} [alphabet] - custom characters to use for Id generation, default to alphaNumeric characters
- * @param {Boolean} [caseSensitive] - whether to use case-sensitive characters
- * @param {Number} [padCount] - if generated ID length is less than this, it's padded with the first character in the `alphabet`
- * @param {String} [suffix] - string to append to ID timestamp, default is random alphanumeric 3 characters string
- * @return {String} ID - example: 'MJ8FU-RVRo'
+ * @param [timestamp] - custom timestamp to generate ID for, defaults to Date.now()
+ * @param [alphabet] - custom characters to use for Id generation, default to alphaNumeric characters
+ * @param [caseSensitive] - whether to use case-sensitive characters
+ * @param [padCount] - if generated ID length is less than this, it's padded with the first character in the `alphabet`
+ * @param [suffix] - string to append to ID timestamp, default is random alphanumeric 3 characters string
+ * @return ID - example: 'MJ8FU-RVRo'
  */
 export function Id ({
   timestamp = Date.now(),
@@ -47,7 +56,7 @@ export function Id ({
   alphabet = caseSensitive ? Id.alphabet : Id.alphabetLower,
   padCount = caseSensitive ? 7 : 9,
   suffix = randomString(3, 3, {alphaNum: true}),
-} = {}) {
+}: IdOptions = {}): string {
   if (!caseSensitive) suffix = suffix.toLowerCase()
 
   // Ensure unique suffix for each millisecond
@@ -64,36 +73,37 @@ export function Id ({
 
   // Garbage clean Id history
   for (const time in Id.history) {
-    if (time < timestamp) delete Id.history[time]
+    // @Note: `time` is a string key compared against a number, exactly as in the original JS
+    if ((time as unknown as number) < timestamp) delete Id.history[time]
   }
 
   // Create hashed Id from Timestamp
   const charsCount = alphabet.length
-  let time = []
+  const timeChars: string[] = []
   let remainder = 0
   while (timestamp >= charsCount) {
     remainder = timestamp % charsCount // can be zero
     timestamp = Math.floor(timestamp / charsCount)
-    time.unshift(alphabet[remainder])
+    timeChars.unshift(alphabet[remainder])
   }
-  time.unshift(alphabet[timestamp])
-  time = time.join('')
-  return padStringLeft(time, Array(padCount).fill(alphabet[0]).join('')) + suffix
+  timeChars.unshift(alphabet[timestamp])
+  const time = timeChars.join('')
+  return padStringLeft(time, Array<string>(padCount).fill(alphabet[0]).join('')) + suffix
 }
 
 // !Important: changing values below may break existing database implementations
-Id.alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
-Id.alphabetLower = '0123456789abcdefghijklmnopqrstuvwxyz'
-Id.minLength = 10 // minimum case-sensitive ID length, including suffix
+Id.alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz' as string
+Id.alphabetLower = '0123456789abcdefghijklmnopqrstuvwxyz' as string
+Id.minLength = 10 as number // minimum case-sensitive ID length, including suffix
 Id.pattern = new RegExp(`^[${Id.alphabet}]+$`)
-Id.history = {} // log of previously generated Ids by timestamp
+Id.history = {} as Record<string, string[]> // log of previously generated Ids by timestamp
 
 /**
  * Check if given string is a valid Short Auto Incrementing ID derived from Timestamp in milliseconds
- * @param {*} value - to check
- * @return {Boolean} true - if valid, else false
+ * @param value - to check
+ * @return true - if valid, else false
  */
-export function isId (value) {
+export function isId (value: unknown): boolean {
   return isString(value) && value.length >= Id.minLength && Id.pattern.test(value)
 }
 
@@ -102,10 +112,9 @@ export function isId (value) {
  * A value is considered to be falsy, if it's one of these:
  *    false, undefined, null, NaN, 0, 0.0, -0, +0, -0.0, +0.0, '', {}, [],
  *
- * @param {*} val - to evaluate for truthiness
- * @returns {boolean}
+ * @param val - to evaluate for truthiness
  */
-export function isTruthy (val) {
+export function isTruthy (val: unknown): boolean {
   if (!val) return false
   if (isList(val) && val.length === 0) return false
   return !(isObject(val) && Object.keys(val).length === 0)
@@ -113,10 +122,10 @@ export function isTruthy (val) {
 
 /**
  * Get Timestamp in Milliseconds from Id string
- * @param {String} string - Id generated by the Id() function
- * @return {Number|Error} Timestamp - in Milliseconds, or throws error of Id is invalid
+ * @param string - Id generated by the Id() function
+ * @return Timestamp - in Milliseconds, or throws error of Id is invalid
  */
-export function timestampFromId (string) {
+export function timestampFromId (string: string): number {
   const alphabet = Id.alphabet
   const radix = alphabet.length
   const id = string.replace(timestampFromId.padPattern, '') // remove time padding
@@ -124,8 +133,9 @@ export function timestampFromId (string) {
   let result = 0
   chars.reverse()
   for (const index in chars) {
-    const multiple = alphabet.indexOf(chars[index])
-    if (multiple === -1) throw new Error(`${timestampFromId.name}() found invalid Id character '${chars[index]}'`)
+    const char = chars[+index]
+    const multiple = alphabet.indexOf(char)
+    if (multiple === -1) throw new Error(`${timestampFromId.name}() found invalid Id character '${char}'`)
     result += multiple * Math.pow(radix, +index)
   }
   return result
@@ -133,18 +143,27 @@ export function timestampFromId (string) {
 
 timestampFromId.padPattern = new RegExp(`^(${Id.alphabet[0]})+`)
 
+/** Geometry Point with latitude and longitude */
+export interface GeoPoint {
+  lat: number
+  lng: number
+}
+
+/** Unit of measurement accepted by `distanceBetween()` */
+export type DistanceUnit = 'km' | 'm' | 'mm'
+
 /**
  * Calculate Distance between two Geometry Points (with latitude and longitude)
  *
  * @note: this method is fast, but inaccurate (using Haversine formula);
  *  for precise calculation - use https://www.npmjs.com/package/geolib
  *
- * @param {Object<lat, lng>} point1
- * @param {Object<lat, lng>} point2
- * @param {String<'km'|'m'|'mm'>} [unit] - of measurements, default is millimeter (length unit saved in database)
- * @returns {Number} distance - between given points in chosen unit
+ * @param point1
+ * @param point2
+ * @param [unit] - of measurements, default is millimeter (length unit saved in database)
+ * @returns distance - between given points in chosen unit
  */
-export function distanceBetween (point1, point2, unit = 'mm') {
+export function distanceBetween (point1: GeoPoint, point2: GeoPoint, unit: DistanceUnit = 'mm'): number {
   const dLat = rad(point2.lat - point1.lat)
   const dLong = rad(point2.lng - point1.lng)
   const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
@@ -167,21 +186,21 @@ export function distanceBetween (point1, point2, unit = 'mm') {
  * @see: https://lowe.github.io/tryzxcvbn/
  *    minimum score of 3 is for safe password in security sensitive applications, 2 is usually enough
  *
- * @param {String} value - to check
- * @param {Number} strength - minimum strength
- * @returns {Boolean} true - if it is
+ * @param value - to check
+ * @param strength - minimum strength
+ * @returns true - if it is
  */
-export function isGoodPassword (value, strength = 2) {
+export function isGoodPassword (value: string, strength: number = 2): boolean {
   return passStrength(value) >= strength
 }
 
 /**
  * Create standardized constant for namespacing modules
- * @param {String} constant - to be used as unique module name
- * @param {String} service - usually from ENV.SERVICE (example: "WEB", "SERVER", "API")
- * @returns {String} namespace - prefixed with service name (example: "~WEB USER_LOGIN")
+ * @param constant - to be used as unique module name
+ * @param service - usually from ENV.SERVICE (example: "WEB", "SERVER", "API")
+ * @returns namespace - prefixed with service name (example: "~WEB USER_LOGIN")
  */
-export function namespace (constant, service) {
+export function namespace (constant: string, service: string): string {
   return `~${service} ${constant}`
 }
 
@@ -190,9 +209,11 @@ export function namespace (constant, service) {
  *
  * @See: https://github.com/dropbox/zxcvbn
  *
- * @param {String} password - to check
- * @return {Object} strength - result
+ * @param password - to check
+ * @return strength - result score
  */
-export function passStrength (password) {
-  return Active.passwordCheck(password).score
+export function passStrength (password: string): number {
+  // @Note: `passwordCheck` is typed as possibly undefined; the original JS called it unconditionally,
+  //    so the non-null assertion preserves the existing throw-on-missing behaviour.
+  return Active.passwordCheck!(password).score
 }
diff --git a/src/core/utils/validators.js b/src/core/utils/validators.ts
similarity index 76%
rename from src/core/utils/validators.js
rename to src/core/utils/validators.ts
index 28845df7..39a76bfd 100644
--- a/src/core/utils/validators.js
+++ b/src/core/utils/validators.ts
@@ -5,11 +5,11 @@
 // Pragmatic email check (aligned with common HTML5-style patterns)
 const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
 
-export function isEmail (value) {
+export function isEmail (value: unknown): boolean {
     return typeof value === 'string' && value.length > 0 && EMAIL_RE.test(value)
 }
 
-export function isLengthMax (value, max) {
+export function isLengthMax (value: unknown, max: number): boolean {
     const s = value == null ? '' : String(value)
     return s.length <= max
 }
@@ -17,6 +17,6 @@ export function isLengthMax (value, max) {
 // require_protocol: true — http:// or https://, non-whitespace remainder
 const URL_WITH_PROTOCOL_RE = /^https?:\/\/\S+$/i
 
-export function isURLWithProtocol (value) {
+export function isURLWithProtocol (value: unknown): boolean {
     return typeof value === 'string' && value.length > 0 && URL_WITH_PROTOCOL_RE.test(value)
 }