@askeleven/sms-guard 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AskEleven
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,267 @@
+# sms-guard
+
+![sms-guard: check a text message before your agent sends it](https://raw.githubusercontent.com/askeleven/sms-guard/main/docs/social-preview.png)
+
+**Check a text message before your agent sends it, and find out whether it will arrive.**
+
+```bash
+npx @askeleven/sms-guard "Hi Ana, your table for 4 is booked for 7pm." --to +13055550100
+```
+
+An agent that writes a long, friendly text does not know it just became twelve SMS
+segments. The provider's API accepts it and bills every segment. Some carriers then
+refuse to deliver it, and nothing tells the agent. Or it sends at 11pm, because it runs
+in UTC and the customer does not. sms-guard is the check that runs first: a CLI for
+pipelines, an MCP server for agents, and a library for everything else. It returns a
+verdict, the facts behind it, and the reason for every problem it finds.
+
+Zero dependencies. No signup, no account, no network.
+
+---
+
+## What it checks
+
+| Check | Verdict |
+|---|---|
+| **Segments**: GSM-7 or UCS-2, counted the way the network counts them, over `--max-segments` (default 5) | Fail |
+| **Send time** outside the recipient's local window (default 08:00-21:00, the federal TCPA calling hours) | Fail |
+| **Invalid number**: not a phone number, or no country code | Fail |
+| **Empty message** | Fail |
+| **Time zone ambiguous**: the area code or country spans zones, and the send time is inside the window in some and outside in others | Review |
+| **Time zone unknown**: toll-free and other non-geographic numbers, countries not in the table | Review |
+| **Public link shorteners** (`bit.ly`, `tinyurl.com`, `t.co` and others), which carriers filter | Review |
+| **No opt-out wording** on a first message (`--first-message`), in English or Spanish | Review |
+| **UCS-2**: which characters force it, and a GSM-7 swap for typographic ones | Note |
+
+**Keep** means nothing was found. **Review** means a person should decide. **Fail** means
+do not send it as it stands.
+
+Segment counting follows GSM 03.38: 160 septets in one segment, 153 per part once split,
+with the extension characters (`^ { } \ [ ~ ] |` and the euro sign) costing two. One
+character outside that alphabet switches the whole message to UCS-2: 70 in one segment,
+67 per part, counted in UTF-16 units, so most emoji cost two. An escape pair or a
+surrogate pair never straddles two parts, which is why a message can be one segment
+longer than dividing by 153 suggests.
+
+For UCS-2, sms-guard lists every character that forced it, with a count. Curly quotes,
+en and em dashes, the ellipsis character, bullets, and odd spaces get a GSM-7
+replacement that reads the same. Accented letters never do: they are the words. A
+message in Spanish will usually be UCS-2, and that is fine. Budget segments for it.
+
+## What it does not do
+
+**It does not send anything, or change anything.** A message that is too long comes
+with a split you can send instead (`--split`), not a rewrite.
+
+**It does not know where the phone is.** The time zone comes from the area code, or the
+country code outside +1. A person who moved from Miami to Los Angeles and kept their
+number is on Eastern time as far as sms-guard knows. Where one code covers more than one
+zone, it says so rather than picking one.
+
+**It does not use national language shift tables.** Some networks can send Spanish or
+Portuguese accents in GSM-7 with a shift table. Support is patchy, so sms-guard counts
+the way nearly every provider actually sends: UCS-2.
+
+**It is not legal advice.** The default window is the federal TCPA calling hours. Some
+states are stricter, and consent is still yours to get.
+
+---
+
+## Example
+
+```
+$ npx @askeleven/sms-guard message.txt --to +13055550100 --at 2026-09-28T01:30:00Z --first-message
+
+FAIL  Do not send this as it stands
+
+      Encoding     UCS-2
+      Length       794 characters, 794 UTF-16 units
+      Segments     12 of up to 67 units each (limit 5)
+      Recipient    +13055550100, Florida, America/New_York
+      Local time   Sun 21:30 EDT, outside 08:00-21:00
+
+FAIL
+  Too many segments
+      12 segments (794 UTF-16 units, 67 per segment in UCS-2), over the
+      limit of 5. Providers usually accept a long message and bill every
+      segment, but some carriers refuse long multi-part messages later and
+      the recipient never gets it, so a success response from the API tells
+      you nothing. Send it as 4 shorter messages instead (splitMessage, or
+      --split), or cut it.
+  Outside allowed hours
+      It would arrive at Sun 21:30 EDT in America/New_York, outside
+      08:00-21:00. The federal TCPA window for telephone solicitations,
+      which covers texts, is 8am to 9pm at the recipient's location, and
+      some states are stricter. Schedule it for the recipient's morning
+      instead. The window next opens at 2026-09-28T12:00:00.000Z (Mon 08:00
+      EDT).
+
+REVIEW
+  No opt-out wording
+      This is the first text to this person and it does not say how to stop
+      them, such as "Reply STOP to opt out" (or "Responde STOP para no
+      recibir más mensajes"). Carriers and the recipient both expect it on a
+      first message.
+
+NOTE
+  Sent as UCS-2
+      UCS-2, because of í U+00ED (7), ó U+00F3 (2), á U+00E1 (2). UCS-2 fits
+      70 characters in one segment instead of 160, and 67 per part instead
+      of 153. Letters are never replaced: they are the words. A message in
+      Spanish will usually be UCS-2, and that is fine; just budget segments
+      for it.
+```
+
+And the same message split:
+
+```
+$ npx @askeleven/sms-guard message.txt --split
+
+PASS  4 messages, each within 5 segments. Send them in order.
+
+  1/4  3 segments, UCS-2, 198 characters
+      Hola María, soy Sofía de Clínica Dental Brisa. ¡Gracias por escribirnos! Vimos tu solicitud sobre la limpieza y el blanqueamiento, y queríamos contarte cómo funciona todo antes de tu primera visita.
+
+  2/4  4 segments, UCS-2, 252 characters
+      La consulta inicial dura unos 45 minutos. Revisamos tu historial, hacemos una evaluación completa y te explicamos las opciones con precios claros, sin sorpresas. Si tienes seguro, tráelo: aceptamos la mayoría de los planes y te ayudamos con el papeleo.
+
+  3/4  4 segments, UCS-2, 264 characters
+      Tenemos horarios disponibles este jueves a las 10:00 o a las 16:30, y el sábado por la mañana. Si ninguno te sirve, dinos qué día te queda mejor y buscamos un espacio. También puedes llamarnos o responder a este mensaje con cualquier pregunta, por pequeña que sea.
+
+  4/4  2 segments, UCS-2, 74 characters
+      ¡Esperamos conocerte pronto! Un saludo del equipo de Clínica Dental Brisa.
+```
+
+The split breaks at blank lines first, then lines, then sentences, then words, and only
+cuts inside a word when one word is too long on its own. Parts are packed as full as the
+breaks allow, and each is counted on its own, so a part with no accents goes back to
+GSM-7.
+
+## Options
+
+```
+--to <number>         Recipient, E.164 preferred (+13055550100).
+--at <time>           When it will be sent, ISO 8601 with an offset or Z. Default now.
+--max-segments <n>    Fail above this many segments. Default 5.
+--window <HH:MM-HH:MM>
+                      Allowed recipient local time. Default 08:00-21:00.
+--first-message       First text to this person: look for opt-out wording.
+--split               Print the message split into parts that each fit.
+--json                Machine-readable output.
+--no-colour           Plain text.
+```
+
+The message is the text on the command line, a file, or standard input (`-`, or piped
+in with no text). Trailing newlines in a file or standard input are dropped.
+
+A number without a `+` is only accepted with 10 digits, or 11 starting with 1, and is
+then read as US or Canadian (+1). Anything else needs its country code. Formatting such
+as spaces, dashes, dots and brackets is ignored.
+
+Exit code `0` means OK to send, `1` means do not send it as it stands (it failed, or it
+needs a person to review it), `2` means it could not run. With `--split`, `0` means every
+part fits. So it gates a pipeline:
+
+```bash
+npx @askeleven/sms-guard message.txt --to "$TO" && ./send-sms "$TO" message.txt
+```
+
+## For agents: MCP server
+
+```bash
+npx @askeleven/sms-guard mcp
+```
+
+It serves two tools over stdio: `check_sms` (one message, with an optional recipient,
+send time, segment limit, window, and first-message flag) and `split_sms` (the parts to
+send instead, in order). `check_sms` returns the `verdict`, the `reasons`, each with a
+stable code and a plain-English explanation, and the `facts`, including
+`nextWindowStart` when the send time is outside the window.
+
+**Claude Code**
+
+```bash
+claude mcp add sms-guard -- npx -y @askeleven/sms-guard mcp
+```
+
+**Claude Desktop, Cursor, and other clients** that take a JSON config:
+
+```json
+{
+  "mcpServers": {
+    "sms-guard": {
+      "command": "npx",
+      "args": ["-y", "@askeleven/sms-guard", "mcp"]
+    }
+  }
+}
+```
+
+The server tells the model how to use the result: never send a message that failed; if
+it failed on segments, send the parts from `split_sms` instead, in order; if it failed on
+quiet hours, schedule it for the recipient's morning rather than send it now; show
+review reasons to a person rather than deciding.
+
+## As a library
+
+```js
+import { checkMessage, splitMessage } from '@askeleven/sms-guard'
+
+const to = '+13055550100'
+const result = checkMessage(text, { to, firstMessage: true })
+
+if (result.verdict === 'fail') {
+  if (result.reasons.some((r) => r.code === 'too_many_segments')) {
+    for (const part of splitMessage(text)) await send(to, part.text)
+  }
+  // quiet_hours: schedule for result.facts.recipient.nextWindowStart instead
+}
+```
+
+`checkMessage(text, options)` takes `to`, `sendAt` (a `Date`, or an ISO string with an
+offset), `maxSegments`, `window`, `firstMessage`, and `now` (a clock, for tests). Every
+reason has a stable `code` (`too_many_segments`, `quiet_hours`, `timezone_ambiguous`, and
+so on) to match on, and a `detail` to show a person.
+
+`encodingOf(text)` returns `'GSM-7'` or `'UCS-2'`. `countSegments(text)` returns the
+encoding, characters, units and segments. `splitMessage(text, { maxSegments })` returns
+the parts, each with its own encoding and segment count.
+
+## Privacy
+
+Nothing leaves your machine. There is no network code at all: time zones come from a
+bundled table and the time zone data built into Node.
+
+## Requirements
+
+Node 20 or newer. No dependencies.
+
+---
+
+## Why we built it
+
+[AskEleven](https://askeleven.com) runs AI employees that text candidates and customers
+for small businesses. One of them wrote a long, friendly first text, with accents, as
+asked. The provider's API accepted every one. A slice of the recipients never got it:
+their carriers refused long multi-part messages, and the only sign was the replies that
+did not come. Nothing about the agent was broken. Nobody told it to count segments.
+
+This is that check, and the other ones we wished had run first.
+
+## Contributing
+
+Issues and pull requests welcome, especially:
+
+- **Wrong time zones.** If an area code or country maps to the wrong zone, or one we list
+  as ambiguous is really a single zone, open an issue with a source.
+- **Missing area codes.** New overlays appear every year. A code sms-guard does not know
+  is reported as unknown, never guessed.
+- **Opt-out wording** in other languages, and shorteners we are missing.
+- **MCP clients** where the server does not work as documented.
+
+Run the tests with `npm test`. They use a fixed clock and no network, so they are offline
+and fast.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

package/bin/cli.js

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util'
+import { readFile } from 'node:fs/promises'
+import { existsSync, statSync } from 'node:fs'
+import {
+  checkMessage,
+  splitMessage,
+  GuardError,
+  DEFAULT_MAX_SEGMENTS,
+  DEFAULT_WINDOW,
+} from '../src/index.js'
+import { formatText, formatSplit } from '../src/report.js'
+import { serve } from '../src/mcp.js'
+import { VERSION } from '../src/version.js'
+
+const USAGE = `
+sms-guard <"message text" | message.txt | ->
+sms-guard mcp
+
+  Checks a text message before you send it, and says whether it is safe to.
+  Counts segments the way the network does (GSM-7 or UCS-2), names the characters
+  that force UCS-2, checks the send time against the recipient's local time, and
+  flags public link shorteners and a missing opt-out on a first message. Runs
+  locally, no network.
+
+Options
+  --to <number>         Recipient, E.164 preferred (+13055550100). A number with
+                        no + and 10 digits is read as US or Canadian.
+  --at <time>           When it will be sent, ISO 8601 with an offset or Z.
+                        Default now.
+  --max-segments <n>    Fail above this many segments. Default ${DEFAULT_MAX_SEGMENTS}.
+  --window <HH:MM-HH:MM>
+                        Allowed recipient local time. Default ${DEFAULT_WINDOW}.
+  --first-message       First text to this person: look for opt-out wording.
+  --split               Print the message split into parts that each fit
+                        --max-segments, to send in order.
+  --json                Machine-readable output.
+  --no-colour           Plain text.
+  --version, --help
+
+  Reads standard input when given "-", or no text and piped input. Trailing
+  newlines in a file or standard input are dropped.
+
+Exit codes
+  0  OK to send (with --split: every part fits)
+  1  do not send as it stands: failed, or needs a person to review
+  2  could not run
+
+Examples
+  npx @askeleven/sms-guard "Hi Ana, your table for 4 is booked for 7pm." --to +13055550100
+  npx @askeleven/sms-guard message.txt --to +447700900123 --first-message --json
+  npx @askeleven/sms-guard message.txt --split
+  npx @askeleven/sms-guard mcp       # MCP server over stdio, for agents
+`
+
+/**
+ * @param {string[]} argv
+ * @returns {Promise<number>}
+ */
+async function main(argv) {
+  if (argv[0] === 'mcp') {
+    await serve()
+    return 0
+  }
+
+  let parsed
+  try {
+    parsed = parseArgs({
+      args: argv,
+      allowPositionals: true,
+      options: {
+        to: { type: 'string' },
+        at: { type: 'string' },
+        'max-segments': { type: 'string' },
+        window: { type: 'string' },
+        'first-message': { type: 'boolean', default: false },
+        split: { type: 'boolean', default: false },
+        json: { type: 'boolean', default: false },
+        // parseArgs has no --no-x negation, so both spellings are declared explicitly.
+        'no-colour': { type: 'boolean', default: false },
+        'no-color': { type: 'boolean', default: false },
+        version: { type: 'boolean', default: false },
+        help: { type: 'boolean', default: false },
+      },
+    })
+  } catch (error) {
+    process.stderr.write(`${/** @type {Error} */ (error).message}\n${USAGE}`)
+    return 2
+  }
+  const { values, positionals } = parsed
+
+  if (values.help) {
+    process.stdout.write(USAGE)
+    return 0
+  }
+  if (values.version) {
+    process.stdout.write(`${VERSION}\n`)
+    return 0
+  }
+
+  let maxSegments = DEFAULT_MAX_SEGMENTS
+  if (values['max-segments'] !== undefined) {
+    maxSegments = Number(values['max-segments'])
+    if (!Number.isInteger(maxSegments) || maxSegments < 1) {
+      process.stderr.write(`--max-segments must be a whole number of 1 or more, got ${values['max-segments']}\n`)
+      return 2
+    }
+  }
+
+  let text
+  try {
+    text = await readInput(positionals)
+  } catch (error) {
+    process.stderr.write(`${/** @type {Error} */ (error).message}\n`)
+    return 2
+  }
+
+  const colour = useColour(values)
+
+  if (values.split) {
+    const parts = splitMessage(text, { maxSegments })
+    if (values.json) {
+      process.stdout.write(`${JSON.stringify({ maxSegments, parts }, null, 2)}\n`)
+    } else if (parts.length === 0) {
+      process.stdout.write('\nThe message is empty. Nothing to split.\n\n')
+    } else {
+      process.stdout.write(formatSplit(parts, { maxSegments, colour }))
+    }
+    return parts.length > 0 && parts.every((p) => p.segments <= maxSegments) ? 0 : 1
+  }
+
+  let result
+  try {
+    result = checkMessage(text, {
+      to: values.to,
+      sendAt: values.at,
+      maxSegments,
+      window: values.window,
+      firstMessage: values['first-message'],
+    })
+  } catch (error) {
+    if (error instanceof GuardError) {
+      process.stderr.write(`${error.message}\n`)
+      return 2
+    }
+    throw error
+  }
+
+  if (values.json) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`)
+  } else {
+    process.stdout.write(formatText(result, { colour }))
+  }
+  return result.verdict === 'keep' ? 0 : 1
+}
+
+/**
+ * One positional that names a file is read from it; "-", or nothing with input piped
+ * in, reads standard input; anything else is the message itself, words joined by
+ * single spaces the way the shell split them.
+ *
+ * @param {string[]} positionals
+ * @returns {Promise<string>}
+ */
+async function readInput(positionals) {
+  if (positionals.length === 0 || (positionals.length === 1 && positionals[0] === '-')) {
+    if (process.stdin.isTTY) throw new Error(`Give the message, a file, or pipe it in.\n${USAGE}`)
+    return dropTrailingNewlines(await readStdin())
+  }
+  if (positionals.length === 1 && existsSync(positionals[0]) && statSync(positionals[0]).isFile()) {
+    return dropTrailingNewlines(await readFile(positionals[0], 'utf8'))
+  }
+  return positionals.join(' ')
+}
+
+/**
+ * @param {string} text
+ * @returns {string}
+ */
+function dropTrailingNewlines(text) {
+  return text.replace(/[\r\n]+$/, '')
+}
+
+/** @returns {Promise<string>} */
+async function readStdin() {
+  /** @type {Buffer[]} */
+  const chunks = []
+  for await (const chunk of process.stdin) chunks.push(chunk)
+  return Buffer.concat(chunks).toString('utf8')
+}
+
+/**
+ * Honours --no-colour, --no-color, NO_COLOR, and a non-TTY stdout.
+ *
+ * @param {Record<string, unknown>} values
+ * @returns {boolean}
+ */
+function useColour(values) {
+  if (values['no-colour'] || values['no-color']) return false
+  if (process.env.NO_COLOR) return false
+  return process.stdout.isTTY === true
+}
+
+main(process.argv.slice(2)).then(
+  (code) => {
+    process.exitCode = code
+  },
+  (error) => {
+    process.stderr.write(`${error?.stack ?? error}\n`)
+    process.exitCode = 2
+  },
+)

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@askeleven/sms-guard",
+  "version": "0.1.0",
+  "description": "Check a text message before an agent (or a person) sends it: GSM-7 or UCS-2, segment count, the recipient's local time, shorteners and opt-out wording. Splits long messages. CLI, library, and MCP server. Zero dependencies.",
+  "type": "module",
+  "license": "MIT",
+  "author": "AskEleven",
+  "homepage": "https://github.com/askeleven/sms-guard",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/askeleven/sms-guard.git"
+  },
+  "bugs": {
+    "url": "https://github.com/askeleven/sms-guard/issues"
+  },
+  "keywords": [
+    "sms",
+    "text-message",
+    "gsm-7",
+    "ucs-2",
+    "sms-segments",
+    "tcpa",
+    "quiet-hours",
+    "deliverability",
+    "mcp",
+    "mcp-server",
+    "ai-agents"
+  ],
+  "bin": {
+    "sms-guard": "bin/cli.js"
+  },
+  "main": "src/index.js",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./src/index.js"
+    }
+  },
+  "files": [
+    "bin",
+    "src",
+    "types",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "test": "node --test",
+    "build:types": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build:types && npm test"
+  },
+  "types": "types/index.d.ts",
+  "devDependencies": {
+    "@types/node": "^22.20.2",
+    "typescript": "^5.9.3"
+  }
+}

package/src/data/countries.js

@@ -0,0 +1,78 @@
+/**
+ * Country calling codes (outside +1) mapped to IANA time zones.
+ *
+ * A country with more than one zone lists them all and is reported as ambiguous. The
+ * number alone cannot say whether a Spanish mobile is in Madrid or the Canary Islands,
+ * so sms-guard does not guess. Countries not listed here are reported as unknown.
+ *
+ * Calling codes are prefix-free, so a number matches at most one row.
+ *
+ * @type {Record<string, [string, string | string[]]>}
+ */
+const ROWS = {
+  // Europe
+  30: ['Greece', 'Europe/Athens'],
+  31: ['Netherlands', 'Europe/Amsterdam'],
+  32: ['Belgium', 'Europe/Brussels'],
+  33: ['France', 'Europe/Paris'],
+  34: ['Spain', ['Europe/Madrid', 'Atlantic/Canary']],
+  36: ['Hungary', 'Europe/Budapest'],
+  39: ['Italy', 'Europe/Rome'],
+  40: ['Romania', 'Europe/Bucharest'],
+  41: ['Switzerland', 'Europe/Zurich'],
+  43: ['Austria', 'Europe/Vienna'],
+  44: ['United Kingdom', 'Europe/London'],
+  45: ['Denmark', 'Europe/Copenhagen'],
+  46: ['Sweden', 'Europe/Stockholm'],
+  47: ['Norway', 'Europe/Oslo'],
+  48: ['Poland', 'Europe/Warsaw'],
+  49: ['Germany', 'Europe/Berlin'],
+  351: ['Portugal', ['Europe/Lisbon', 'Atlantic/Azores']],
+  352: ['Luxembourg', 'Europe/Luxembourg'],
+  353: ['Ireland', 'Europe/Dublin'],
+  358: ['Finland', 'Europe/Helsinki'],
+  420: ['Czechia', 'Europe/Prague'],
+
+  // Latin America
+  52: ['Mexico', ['America/Mexico_City', 'America/Cancun', 'America/Chihuahua', 'America/Hermosillo', 'America/Mazatlan', 'America/Tijuana']],
+  54: ['Argentina', 'America/Argentina/Buenos_Aires'],
+  55: ['Brazil', ['America/Sao_Paulo', 'America/Manaus', 'America/Cuiaba', 'America/Rio_Branco', 'America/Noronha']],
+  56: ['Chile', ['America/Santiago', 'America/Punta_Arenas', 'Pacific/Easter']],
+  57: ['Colombia', 'America/Bogota'],
+  58: ['Venezuela', 'America/Caracas'],
+  502: ['Guatemala', 'America/Guatemala'],
+  503: ['El Salvador', 'America/El_Salvador'],
+  504: ['Honduras', 'America/Tegucigalpa'],
+  505: ['Nicaragua', 'America/Managua'],
+  506: ['Costa Rica', 'America/Costa_Rica'],
+  507: ['Panama', 'America/Panama'],
+  51: ['Peru', 'America/Lima'],
+  591: ['Bolivia', 'America/La_Paz'],
+  593: ['Ecuador', ['America/Guayaquil', 'Pacific/Galapagos']],
+  595: ['Paraguay', 'America/Asuncion'],
+  598: ['Uruguay', 'America/Montevideo'],
+
+  // Elsewhere
+  27: ['South Africa', 'Africa/Johannesburg'],
+  61: ['Australia', ['Australia/Sydney', 'Australia/Brisbane', 'Australia/Adelaide', 'Australia/Darwin', 'Australia/Perth']],
+  63: ['Philippines', 'Asia/Manila'],
+  64: ['New Zealand', ['Pacific/Auckland', 'Pacific/Chatham']],
+  65: ['Singapore', 'Asia/Singapore'],
+  81: ['Japan', 'Asia/Tokyo'],
+  82: ['South Korea', 'Asia/Seoul'],
+  86: ['China', 'Asia/Shanghai'],
+  91: ['India', 'Asia/Kolkata'],
+  234: ['Nigeria', 'Africa/Lagos'],
+  254: ['Kenya', 'Africa/Nairobi'],
+  852: ['Hong Kong', 'Asia/Hong_Kong'],
+  971: ['United Arab Emirates', 'Asia/Dubai'],
+  972: ['Israel', 'Asia/Jerusalem'],
+}
+
+/** @type {Map<string, import('./nanp.js').ZoneEntry>} */
+export const COUNTRY_CODES = new Map(
+  Object.entries(ROWS).map(([code, [region, zone]]) => [
+    code,
+    { region, zones: Array.isArray(zone) ? zone : [zone] },
+  ]),
+)