@botim/mp-debug-sdk 0.8.0 → 1.2.0

package/dist/vite/plugin.js

@@ -1,6 +1,6 @@
 // src/vite/resolve-config.ts
 import { readFileSync, existsSync } from "fs";
-import { resolve, isAbsolute } from "path";
+import { resolve, isAbsolute, basename } from "path";
 import { createHash } from "crypto";
 
 // src/errors.ts
@@ -16,7 +16,7 @@ var BotimConfigError = class extends Error {
 
 // src/vite/resolve-config.ts
 var VALID_ENVS = ["dev", "uat", "beta", "prod"];
-var ID_PATTERN = /^[a-z][a-z0-9_-]{1,63}$/i;
+var ID_PATTERN = /^[a-z][a-z0-9._-]{1,127}$/i;
 function defaultMapMode(mode) {
   if (mode === "development") return "dev";
   if (mode === "production") return "prod";
@@ -38,30 +38,44 @@ function resolveBotimConfig(mode, root, opts = {}) {
   }
   const env = mapped;
   const projectRoot = isAbsolute(root) ? root : resolve(process.cwd(), root);
-  const fileName = resolveFileName(opts.configFileName, env, mode);
-  const filePath = isAbsolute(fileName) ? fileName : resolve(projectRoot, fileName);
+  const explicit = opts.configFileName !== void 0;
+  const candidates = explicit ? [
+    {
+      env,
+      path: (() => {
+        const fileName = resolveFileName(opts.configFileName, env, mode);
+        return isAbsolute(fileName) ? fileName : resolve(projectRoot, fileName);
+      })()
+    }
+  ] : buildCandidatePaths(projectRoot, env);
   const inline = opts.inlineConfig;
-  const inlineHasIdentity = typeof inline?.mp_id === "string" && inline.mp_id.length > 0 ? true : typeof inline?.miniProgramId === "string" && inline.miniProgramId.length > 0;
+  const inlineHasIdentity = typeof inline?.app_id === "string" && inline.app_id.length > 0 || typeof inline?.miniProgramId === "string" && inline.miniProgramId.length > 0;
+  const source = candidates.find((c) => existsSync(c.path));
   let raw;
   let parsedFromFile = {};
-  if (existsSync(filePath)) {
-    raw = readFileSync(filePath, "utf8");
+  if (source) {
+    raw = readFileSync(source.path, "utf8");
     try {
       parsedFromFile = JSON.parse(raw);
     } catch (err) {
       const detail = err instanceof Error ? err.message : String(err);
-      throw new BotimConfigError(`failed to parse JSON in ${filePath}: ${detail}`, {
+      throw new BotimConfigError(`failed to parse JSON in ${source.path}: ${detail}`, {
         code: "config-invalid-json",
-        path: filePath
+        path: source.path
       });
     }
-  } else if (!inlineHasIdentity) {
+    if (source.env !== env) {
+      console.warn(
+        `[@botim/debug-sdk] no config for env "${env}"; borrowed app_id from ${basename(source.path)} (env stays ${env})`
+      );
+    }
+  } else if (explicit && !inlineHasIdentity) {
+    const wanted = candidates[0].path;
     throw new BotimConfigError(
-      `expected config file not found: ${filePath}
-       Either create ${fileName} at the project root with at least { "mp_id": "..." },
-       pass an explicit { configFileName } / { config: { mp_id: "..." } } to botimDebug(),
-       or supply inlineConfig with mp_id when calling resolveBotimConfig() directly.`,
-      { code: "config-missing", path: filePath }
+      `expected config file not found: ${wanted}
+       Create it with at least { "app_id": "..." }, pass { configFileName },
+       or supply inlineConfig with app_id.`,
+      { code: "config-missing", path: wanted }
     );
   }
   const parsed = {
@@ -75,22 +89,28 @@ function resolveBotimConfig(mode, root, opts = {}) {
     parsed.package_url = { ...parsedFromFile.package_url, ...inline?.package_url };
   }
   if (parsed.deleted === 1) {
+    const label = source?.path ?? "inlineConfig";
     throw new BotimConfigError(
-      `${filePath} reports the mini-program as deleted (deleted: 1). Cannot ship debug SDK against a retired mini-program.`,
-      { code: "config-deleted", path: filePath }
+      `${label} reports the mini-program as deleted (deleted: 1). Cannot ship debug SDK against a retired mini-program.`,
+      { code: "config-deleted", path: source?.path }
     );
   }
-  const idValue = parsed.mp_id ?? parsed.miniProgramId;
-  if (typeof idValue !== "string" || idValue.length === 0) {
-    throw new BotimConfigError(
-      `${filePath} is missing required field "mp_id" (must be a non-empty string)`,
-      { code: "config-missing-field", path: filePath }
-    );
-  }
-  if (!ID_PATTERN.test(idValue)) {
-    throw new BotimConfigError(
-      `${filePath} field "mp_id" must match ${ID_PATTERN.toString()} (got: ${JSON.stringify(idValue)})`,
-      { code: "config-invalid-id", path: filePath }
+  const idValue = parsed.app_id ?? parsed.miniProgramId;
+  let miniProgramId;
+  if (typeof idValue === "string" && idValue.length > 0) {
+    if (!ID_PATTERN.test(idValue)) {
+      const label = source?.path ?? "inlineConfig";
+      throw new BotimConfigError(
+        `${label} field "app_id" must match ${ID_PATTERN.toString()} (got: ${JSON.stringify(idValue)})`,
+        { code: "config-invalid-id", path: source?.path }
+      );
+    }
+    miniProgramId = idValue;
+  } else {
+    miniProgramId = synthesizeMiniProgramId(projectRoot, env);
+    const reason = source ? `config ${basename(source.path)} has no app_id` : "no botim_config.*.json found for any env";
+    console.warn(
+      `[@botim/debug-sdk] ${reason}; synthesized id ${miniProgramId} (env=${env})`
     );
   }
   const md5 = typeof parsed.app?.md5 === "string" ? parsed.app.md5 : typeof parsed.package_url?.md5 === "string" ? parsed.package_url.md5 : void 0;
@@ -101,13 +121,13 @@ function resolveBotimConfig(mode, root, opts = {}) {
   } else if (versionForSig && md5) {
     buildSignature = `v${versionForSig}+md5:${md5.slice(0, 12)}`;
   } else {
-    const sigSource = raw ?? JSON.stringify({ mp_id: idValue, env, version: versionForSig, app: parsed.app });
+    const sigSource = raw ?? JSON.stringify({ app_id: miniProgramId, env, version: versionForSig, app: parsed.app });
     buildSignature = "sha256:" + createHash("sha256").update(sigSource).digest("hex").slice(0, 12);
   }
   const cfg = {
     // Spread first so the canonical fields below override anything inherited.
     ...parsed,
-    miniProgramId: idValue,
+    miniProgramId,
     env,
     buildSignature,
     appName: typeof parsed.app_id === "string" ? parsed.app_id : parsed.appName,
@@ -140,6 +160,20 @@ function resolveFileName(override, env, mode) {
     { code: "config-invalid-filename" }
   );
 }
+function synthesizeMiniProgramId(projectRoot, env) {
+  const dir = basename(projectRoot);
+  const hash = createHash("sha256").update(`${dir}:${env}`).digest("hex").slice(0, 8);
+  return `mp-${hash}`;
+}
+function buildCandidatePaths(projectRoot, selected) {
+  const order = [selected, ...VALID_ENVS.filter((e) => e !== selected)];
+  const out = [];
+  for (const e of order) {
+    out.push({ env: e, path: resolve(projectRoot, `botim_config.${e}.json`) });
+    out.push({ env: e, path: resolve(projectRoot, `botim.${e}.json`) });
+  }
+  return out;
+}
 
 // src/vite/plugin.ts
 var VIRTUAL_ID = "virtual:botim/config";
@@ -185,6 +219,41 @@ export const botimConfig = Object.freeze(${JSON.stringify(resolved)});
 export default botimConfig;
 `;
       return { code: body, map: null };
+    },
+    // Enable relay debugging from vite.config alone: when `relayToken` is set,
+    // inject an `enableRemoteDebug(...)` bootstrap into index.html. This hook
+    // runs in BOTH dev (`serve`) and `build`, so the same call ships to the
+    // built/deployed bundle. App source is never touched; removing the option
+    // (or the plugin) removes the injection.
+    transformIndexHtml: {
+      order: "pre",
+      handler() {
+        const token = options.relayToken;
+        if (typeof token !== "string" || token.length === 0) return void 0;
+        if (!resolved) return void 0;
+        const endpoint = (options.relayUrl ?? resolved.relayUrl ?? "").replace(/\/+$/, "");
+        if (!endpoint) {
+          console.warn(
+            "[@botim/debug-sdk:vite] relayToken set but no relayUrl \u2014 debug bootstrap NOT injected (pass relayUrl)."
+          );
+          return void 0;
+        }
+        const debugOptions = {
+          endpoint,
+          token,
+          config: { miniProgramId: resolved.miniProgramId, env: resolved.env },
+          consent: { userOptIn: true }
+        };
+        return [
+          {
+            tag: "script",
+            attrs: { type: "module" },
+            children: `import { enableRemoteDebug } from '@botim/mp-debug-sdk';
+enableRemoteDebug(${JSON.stringify(debugOptions)}).catch(() => {});`,
+            injectTo: "head-prepend"
+          }
+        ];
+      }
     }
   };
 }

package/dist/vite/virtual-shim.d.ts

@@ -1,12 +1,12 @@
 /**
  * Ambient module declaration for the virtual module emitted by
- * `@botim/debug-sdk/vite`. Add this file to your `tsconfig.json#include`
- * (or reference `@botim/debug-sdk/vite` from `compilerOptions.types`) and
+ * `@botim/mp-debug-sdk/vite`. Add this file to your `tsconfig.json#include`
+ * (or reference `@botim/mp-debug-sdk/vite` from `compilerOptions.types`) and
  * `import { botimConfig } from 'virtual:botim/config'` will type-check.
  */
 
 declare module 'virtual:botim/config' {
-  import type { BotimConfig } from '@botim/debug-sdk';
+  import type { BotimConfig } from '@botim/mp-debug-sdk';
   /**
    * Resolved BotimConfig augmented with the optional `relayUrl` carried
    * over from the Vite plugin's `relayUrl` option (when provided). Pass

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botim/mp-debug-sdk",
-  "version": "0.8.0",
+  "version": "1.2.0",
   "description": "Remote-debug SDK for BOTIM mini-programs — streams console, network, and error events to a BOTIM debug-relay for live inspection, with an AI-observable command channel.",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -17,6 +17,11 @@
       "import": "./dist/types.js",
       "require": "./dist/types.cjs"
     },
+    "./auto": {
+      "types": "./dist/auto.d.ts",
+      "import": "./dist/auto.js",
+      "require": "./dist/auto.cjs"
+    },
     "./vite": {
       "types": "./dist/vite/plugin.d.ts",
       "import": "./dist/vite/plugin.js",
@@ -25,9 +30,11 @@
     "./vite/virtual-shim": "./dist/vite/virtual-shim.d.ts"
   },
   "files": [
-    "dist",
-    "LICENSE",
-    "README.md"
+    "dist/**/*.js",
+    "dist/**/*.cjs",
+    "dist/**/*.d.ts",
+    "dist/**/*.d.cts",
+    "LICENSE"
   ],
   "scripts": {
     "build": "tsup && npm run build:copy-shim",
@@ -37,7 +44,9 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "check-no-leaks": "node scripts/check-no-leaks.mjs",
-    "prepublishOnly": "npm run type-check && npm test && npm run build && npm run check-no-leaks"
+    "prepublishOnly": "npm run type-check && npm test && npm run build && npm run check-no-leaks",
+    "prepack": "node -e \"const fs=require('node:fs');if(fs.existsSync('README.md'))fs.renameSync('README.md','.README.repo.md')\"",
+    "postpack": "node -e \"const fs=require('node:fs');if(fs.existsSync('.README.repo.md'))fs.renameSync('.README.repo.md','README.md')\""
   },
   "keywords": [
     "botim",
@@ -55,9 +64,13 @@
     "node": ">=16.0.0"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
   },
-  "sideEffects": false,
+  "sideEffects": [
+    "./dist/auto.js",
+    "./dist/auto.cjs"
+  ],
   "devDependencies": {
     "@types/node": "24.9.2",
     "happy-dom": "^15.11.7",

package/README.md

@@ -1,265 +0,0 @@
-# @botim/mp-debug-sdk
-
-> Remote-debug your BOTIM mini-program. Stream console, network, and error events to a debug-relay you control; let humans tail live and let AI agents query, subscribe, and issue safe commands back to the device.
-
-## Why
-
-Mini-programs run on user devices in environments you can't easily attach a debugger to. This SDK gives you:
-
-- **Live logs** of `console.*`, `fetch`, `XMLHttpRequest`, and uncaught errors.
-- **AI-observable sessions** — every event indexed by `(miniProgramId, deviceId, sid)` so resolver agents can pull errors and reproduce bugs without a human in the loop.
-- **Safe AI command channel** — agents can `reload`, `dump-state`, `set-feature-flag`, `screenshot`, `ping`, `exec` (default-on remote REPL), or any custom command you allow. Anything not registered is rejected.
-- **Built-in redaction** before the event ever enters the in-memory buffer.
-
-## Install
-
-> **If your project's `.npmrc` pins the `@botim` scope to a private registry, override it for this package.**
-> This SDK is published to public npm. If your `.npmrc` contains a line like `@botim:registry=<private-mirror-url>`, plain `npm install @botim/mp-debug-sdk` will route to the private mirror, not find the package, and fail. Use:
-
-```bash
-npm install @botim/mp-debug-sdk --registry=https://registry.npmjs.org/
-```
-
-If your repo has no `@botim` scope override, the flag is harmless — npm uses `registry.npmjs.org` by default. Don't permanently re-pin the `@botim` scope to public npm in your `.npmrc`: it would shadow whatever private registry your other `@botim/*` packages come from.
-
-## 1. Add the env config files
-
-Each environment of your mini-program ships with one config file at the project root, in the standard BOTIM mini-program schema:
-
-```jsonc
-// botim.dev.json (real schema — abridged)
-{
-  "mp_id": "mbrx_p2p_dev",
-  "app_id": "me.botim.rd.p2p",
-  "version": "0.0.127",
-  "app": {
-    "version": "0.0.127",
-    "md5": "fbd6b256d4961abe1cc7703984c31857"
-  },
-  "framework": { "version": "57.0.1" },
-  "category": "Finance"
-  // ...all other BOTIM platform fields are passed through untouched
-}
-```
-
-Repeat for `botim.uat.json`, `botim.beta.json`, `botim.prod.json`. The plugin reads `mp_id` (the canonical mini-program id; the legacy `miniProgramId` field is also accepted) and derives a deterministic `buildSignature` from `version` + `app.md5` so it correlates with each release rather than churning on platform-side metadata changes.
-
-The plugin also auto-fills `app.name` (from `app_id`) and `app.version` (from `version`) so your `enableRemoteDebug` call doesn't have to repeat them.
-
-## 2. Wire the Vite plugin
-
-```ts
-// vite.config.ts
-import { botimDebug } from '@botim/mp-debug-sdk/vite';
-
-// Pick the relay endpoint at build time. You control where logs go —
-// the SDK never phones home to anything but this URL.
-const RELAY_URL = process.env.RELAY_URL ?? 'http://localhost:8090';
-
-export default (({ mode }: { mode: string }) => ({
-  plugins: [botimDebug({ mode, relayUrl: RELAY_URL })],
-}));
-```
-
-Switch envs by changing the build flag — no runtime branches:
-
-```bash
-vite build --mode dev      # picks botim.dev.json
-vite build --mode uat      # picks botim.uat.json
-vite build --mode beta     # picks botim.beta.json
-vite build --mode prod     # picks botim.prod.json
-```
-
-If a matching `botim.{mode}.json` is missing or malformed, **the build fails** — wrong-env bundles can't ship.
-
-### Plugin options
-
-| option | type | purpose |
-|---|---|---|
-| `mode` | `string` (optional) | Force a specific mode. When omitted, the plugin auto-reads `mode` from Vite's resolved config. |
-| `mapMode` | `(mode) => env` (optional) | Map a custom Vite mode name to a BOTIM env (defaults: `development → dev`, `production → prod`, others pass through). |
-| `relayUrl` | `string` (optional) | The relay endpoint the SDK will POST to. Baked into `virtual:botim/config` as `botimConfig.relayUrl`. Trailing slash stripped automatically. |
-| `root` | `string` (optional) | Project root for resolving `botim.{mode}.json`. Defaults to Vite's resolved root. |
-
-## 3. (TypeScript) reference the virtual-module shim
-
-In any `.d.ts` your tsconfig picks up (or in `tsconfig.json#compilerOptions.types`):
-
-```ts
-/// <reference types="@botim/mp-debug-sdk/vite/virtual-shim" />
-```
-
-Now `import { botimConfig } from 'virtual:botim/config'` type-checks (`botimConfig.relayUrl` included).
-
-## 4. Enable remote debug at the entry point
-
-```ts
-import { enableRemoteDebug } from '@botim/mp-debug-sdk';
-import { botimConfig } from 'virtual:botim/config';
-
-const handle = await enableRemoteDebug({
-  // The relay URL the plugin baked in. Falls back to same-origin if you
-  // didn't pass `relayUrl` to the plugin (e.g. you're using a dev proxy).
-  // For a gateway-hosted relay this is the gateway origin (optionally with a
-  // path prefix), e.g. 'https://proxy-uat-ae.botim.me/botim-cli-gateway'.
-  endpoint: botimConfig.relayUrl ?? location.origin,
-  // Relay connect token (rdt_…). REQUIRED for gateway-hosted relays, which
-  // gate attach on `Authorization: Bearer rdt_…`. Mint one bound to this
-  // (mpId, env) with `botim-cli relay token --mp <id> --env uat` (24 h TTL).
-  // Omit for the legacy standalone relay, which ignores it.
-  token: import.meta.env.VITE_RELAY_TOKEN,
-  config: botimConfig,
-  // app is optional — plugin auto-fills from app_id + version in
-  // botim.{env}.json. Override only when you want a different name/version
-  // reported in events.
-  // app: { name: 'checkout-mp', version: '1.4.0' },
-
-  // dev/uat/beta builds: consent is implicit
-  // prod builds: provide a hostToken or set userOptIn after a privacy dialog
-  consent: { userOptIn: true },
-
-  // Optional host hooks the AI command channel can invoke
-  builtins: {
-    reload: () => location.reload(),
-    getState: () => app.snapshot(),
-    setFeatureFlag: (key, value) => app.flags.set(key, value),
-    screenshot: async () => await canvas.toBase64PNG(),
-  },
-
-  onError: (err) => console.warn('[debug-sdk]', err),
-});
-```
-
-That's it — `console.*`, network calls, and uncaught errors now stream to the relay.
-
-### Cross-origin setup
-
-The SDK posts directly to `endpoint` — there's no proxy required. Your relay must allow the page's origin via CORS. A reference debug-relay implementation typically defaults to `CORS_ORIGINS=*` for development; tighten via env when going to production:
-
-```bash
-CORS_ORIGINS=https://my-mp.example.com,https://staging.example.com
-```
-
-## 5. Remote REPL (`exec`) — default-on
-
-Once `enableRemoteDebug` returns, an attached agent can send a JS snippet to the device and read back the value, captured `console.*` output, or thrown error. No host wiring needed.
-
-```bash
-# From any terminal that can reach your relay:
-curl -sX POST "<RELAY_URL>/v1/mp/<MP_ID>/devices/<DEVICE_ID>/commands" \
-  -H 'content-type: application/json' \
-  -d '{"name":"exec","args":{"code":"console.log(\"hi\"); return window.location.href"}}'
-```
-
-Result event:
-
-```jsonc
-{
-  "type": "command-ack",
-  "payload": {
-    "command": "exec",
-    "ok": true,
-    "result": {
-      "value": "https://my-mp.example.com/page",
-      "logs": [{"method":"log","args":["hi"],"ts": 1735324800123}],
-      "durationMs": 2
-    }
-  }
-}
-```
-
-Inside the snippet, `BOT`, `window`, and `document` are bound as locals (with `BOT` resolved best-effort from `window.BOT` or Angular DI; `null` if unavailable). Top-level `await` works. Code is capped at 8 KB and 30 s.
-
-**To opt out** (e.g. you ship a non-debug release that still uses the SDK for telemetry only):
-
-```ts
-await enableRemoteDebug({
-  // ...,
-  builtins: { exec: false },
-});
-```
-
-**To inject extra locals** for your app:
-
-```ts
-await enableRemoteDebug({
-  // ...,
-  builtins: { exec: { globals: { app: myApp, store: myStore } } },
-});
-// agent can then call: { code: "return store.getState().user" }
-```
-
-> Pre-buffer redaction (headers, JWT/long-token regex) is applied to `result.value` and `result.logs` before they leave the device buffer. The existing prod consent gate (`hostToken` or `userOptIn`) gates whether attach happens at all. See `docs/recipes/exec.md` for deeper notes.
-
-## 6. Custom commands (optional)
-
-Any AI agent with the right scope can request a command. The SDK only runs commands registered via `registerCommand`:
-
-```ts
-handle.registerCommand('clear-cart', async () => {
-  await store.clearCart();
-  return { cleared: true };
-});
-
-handle.registerCommand('set-locale', async (args) => {
-  if (typeof args.locale !== 'string') throw new Error('args.locale required');
-  i18n.setLocale(args.locale);
-  return { locale: args.locale };
-});
-```
-
-Anything not registered gets a `command-rejected` event with reason `unknown-command`.
-
-## 7. Lifecycle
-
-```ts
-await handle.flush();    // force-send buffered events
-await handle.stop();     // uninstall interceptors + drain queue
-console.log(handle.sid); // server-issued session id
-```
-
-## Production safety
-
-- **No-op on disable**: `enableRemoteDebug({ enabled: false, ... })` returns an inert handle. No I/O, no globals wrapped.
-- **Synchronous validation**: bad config or missing consent throws immediately, *before* any interceptor is installed.
-- **No-throw runtime**: once attached, transport/network/redaction errors only surface via `onError`. Your app never observes a thrown error from the SDK.
-- **Defense-in-depth redaction**: header denylist + JWT/long-token regex + body byte cap, applied **before** events enter the buffer.
-- **Single in-flight long-poll**: at most one outbound request per device for the AI command channel.
-- **Self-event suppression**: the SDK captures `fetch` reference at import time and routes its own ingest/poll calls through that pre-interception fetch — no risk of the SDK observing itself and creating a feedback loop.
-
-## Debugging a live mini-program
-
-Once your build is wired and shipped, see **[`docs/live-debugging.md`](./docs/live-debugging.md)** for the end-to-end runbook against your debug-relay deployment. It covers:
-
-- pointing the Vite plugin at the live relay URL,
-- pulling errors and tailing sessions from the admin UI,
-- a dedicated **For AI agents** section with `curl` recipes for `/v1/mp/{mpId}/events`, the SSE live-tail, and command POSTs.
-
-## API reference
-
-| Symbol | Purpose |
-|---|---|
-| `enableRemoteDebug(options)` | Boot the SDK; returns a `RemoteDebugHandle`. |
-| `botimDebug({ mode?, relayUrl?, mapMode? })` | Vite plugin; wire in `vite.config.ts`. |
-| `resolveBotimConfig(mode, root)` | Pure resolver, for non-Vite bundlers. |
-| `BotimConfig` | Type of `botim.{env}.json` after resolution. |
-| `BotimConfigError` | Synchronous throw on bad/missing config. |
-| `BotimConsentError` | Synchronous throw on missing consent in prod. |
-| `RemoteDebugHandle.registerCommand(name, handler)` | Allow an AI command. |
-| `RemoteDebugHandle.flush()` | Force-flush the in-memory buffer. |
-| `RemoteDebugHandle.stop()` | Uninstall and drain the queue. |
-
-## AI debug skill (Claude Code)
-
-A Claude Code skill that teaches AI agents how to wire and consume this SDK lives at `.claude/skills/botim-debug-relay/SKILL.md`. Open Claude Code from this repo and the skill auto-loads — no setup needed. To use it from anywhere on your machine:
-
-```bash
-cp -r .claude/skills/botim-debug-relay ~/.claude/skills/
-```
-
-> **The file in this repo is a mirror.** The canonical copy lives in `botim-debug-relay/.claude/skills/botim-debug-relay/SKILL.md`. **Do not edit the SDK-side copy directly** — your changes will be overwritten by the next sync. Edit in the relay repo, then run `bash bin/sync-skill.sh` from that repo to propagate here.
-
-## License
-
-[ISC](./LICENSE) © BOTIM
-