@futurewindai/wotchi 0.1.0-beta.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,128 @@
+# Wotchi
+
+> Your production's night shift.
+
+Wotchi is a lightweight incident assistant for Node.js applications. It is intended to help small teams turn repeated Express and NestJS application errors into a small number of useful console or Telegram alerts without operating a separate monitoring stack.
+
+> **Project status:** Private beta candidate (`0.1.0-beta.1`). Phases 1–8 are implemented and locally validated, including bounded incident processing, console and Telegram alerts, Express 4/5 middleware, NestJS 10/11 exception-filter integration, opt-in crash observation, security gates, performance budgets, packed-tarball examples, and Node.js 18–26 CI. The source repository is public; the npm package is not published yet.
+
+The working package name is `@futurewindai/wotchi`. The founder accepted the documented Wotchi trademark risk for the beta release on 2026-08-08; this is not legal clearance. The package remains unpublished until the exact release snapshot and gates are verified.
+
+## Planned v0.1 Scope
+
+- one framework-independent TypeScript core;
+- focused integrations for Express 4/5 and NestJS 10/11;
+- manual exception and structured error-event capture;
+- sensitive-data redaction before storage, fingerprinting, logging, or transmission;
+- stable fingerprints and deterministic incident summaries;
+- bounded in-memory grouping, thresholds, cooldowns, and notification queueing;
+- console and Telegram notifiers;
+- CommonJS and ECMAScript module package exports;
+- measured latency, CPU, heap, queue, and package-size release gates.
+
+The package exposes a root entry point plus focused `/express` and `/nest` entry points. Framework adapters are loaded only through their subpaths, and they observe errors while leaving response ownership with Express or NestJS.
+
+Express applications install the middleware after routes and before the existing final error handler:
+
+```ts
+import express from "express";
+import { consoleNotifier, createWotchi } from "@futurewindai/wotchi";
+import { wotchiErrorHandler } from "@futurewindai/wotchi/express";
+
+const app = express();
+const wotchi = createWotchi({
+  service: "orders-api",
+  environment: "production",
+  notifiers: [consoleNotifier()],
+});
+
+app.use(wotchiErrorHandler(wotchi));
+```
+
+NestJS applications register the delegating global filter once after creating the application:
+
+```ts
+import { registerWotchiNest } from "@futurewindai/wotchi/nest";
+
+registerWotchiNest(app, wotchi);
+```
+
+Telegram is an optional self-hosted notifier. The application owner creates a bot with BotFather, starts or adds it to the destination chat, and keeps the credentials outside source control:
+
+```ts
+import { consoleNotifier, createWotchi, telegramNotifier } from "@futurewindai/wotchi";
+
+const wotchi = createWotchi({
+  service: "orders-api",
+  environment: "production",
+  notifiers: [
+    consoleNotifier(),
+    telegramNotifier({
+      botToken: process.env.WOTCHI_TELEGRAM_BOT_TOKEN ?? "",
+      chatId: process.env.WOTCHI_TELEGRAM_CHAT_ID ?? "",
+    }),
+  ],
+});
+```
+
+Wotchi does not ship a shared bot token. Telegram delivery is queued outside the request path, uses bounded HTTPS timeouts/retries, and sends only the sanitized incident alert.
+
+Crash observation is also opt-in:
+
+```ts
+import { registerWotchiProcessMonitor } from "@futurewindai/wotchi";
+
+const monitor = registerWotchiProcessMonitor(wotchi);
+// monitor.unregister() when the host intentionally stops observing crashes
+```
+
+The implemented core can be exercised directly:
+
+```ts
+import { consoleNotifier, createWotchi } from "@futurewindai/wotchi";
+
+const wotchi = createWotchi({
+  service: "orders-api",
+  environment: "production",
+  notifiers: [consoleNotifier()],
+});
+
+wotchi.captureException(new Error("database query failed"));
+await wotchi.flush();
+```
+
+The default policy emits after three matching errors in one minute and suppresses duplicate alerts during the cooldown. The capture path remains synchronous; `flush()` is only needed when the host explicitly wants to wait for notifier work.
+
+## Product Principles
+
+- **Host safety:** Wotchi must not break, suppress, or materially delay the application's normal error flow.
+- **Bounded overhead:** memory, payloads, groups, and queued notifications must all have explicit limits.
+- **Privacy first:** request bodies, response bodies, raw headers, and arbitrary environment variables are outside the first release.
+- **Deterministic first:** the MVP must work without an AI provider, database, hosted account, or collector.
+- **Honest compatibility:** the MVP targets Node.js 18.18 and later. Supported framework/module combinations are claimed only after packed-tarball CI verification. Maintained Node.js LTS versions are recommended for production.
+
+## Not Planned for v0.1
+
+- a full observability, APM, or log-management platform;
+- a hosted dashboard, collector, or persistent incident history;
+- AI-generated summaries;
+- Slack, Discord, email, or generic webhook notifiers;
+- logger transports, Docker collectors, Kubernetes agents, or Helm charts in the npm SDK itself; a separate future collector/relay deployment may receive its own Docker and Helm milestone;
+- automatic remediation.
+
+A token-based hosted demo viewer is a separate possible future milestone, not part of the package MVP.
+
+## Project Documents
+
+- [Architecture and package boundaries](docs/ARCHITECTURE.md)
+- [Setup](docs/SETUP.md)
+- [Configuration](docs/CONFIGURATION.md)
+- [Testing and smoke validation](docs/TESTING.md)
+- [Security and privacy notes](docs/SECURITY.md)
+- [Development workflow](docs/DEVELOPMENT.md)
+- [Security policy](SECURITY.md)
+- [Contributing guide](CONTRIBUTING.md)
+- [Changelog](CHANGELOG.md)
+- [Apache License 2.0](LICENSE)
+
+Wotchi is an early open-source project from FutureWind AI. Contributions and product feedback should stay within the documented scope and avoid real secrets or customer error data.

package/SECURITY.md

@@ -0,0 +1,17 @@
+# Security Policy
+
+## Supported Versions
+
+Wotchi is currently pre-release. The package targets consumers running Node.js `>=18.18.0` and is built and tested across the maintained Node.js 18–26 matrix. Node.js versions below 18.18 are not supported.
+
+The current pre-release package contains the framework-independent capture core, console and Telegram notifiers, Express 4/5 middleware, NestJS 10/11 exception-filter integration, and opt-in process monitoring. The package has not been published to npm. Supported runtime and framework combinations are documented only after the packed-tarball compatibility and release-security gates pass.
+
+## Reporting a Vulnerability
+
+Do not disclose a suspected vulnerability, exploit detail, credential, token, or real customer error in a public issue, discussion, pull request, or example.
+
+Use [GitHub private vulnerability reporting](https://github.com/FutureWindAI/wotchi/security/advisories/new) when it is available for this repository. If that private form is unavailable, open a public issue containing no sensitive detail and ask the maintainers to establish a private reporting channel.
+
+Include only the minimum sanitized information needed to reproduce the problem. Remove application secrets, personal data, proprietary source, production URLs, and raw customer payloads.
+
+We will acknowledge a valid private report, investigate its scope, and coordinate disclosure after a fix or mitigation is ready. Response-time commitments will be added only when the project has an active release and a maintained security process.

package/dist/cjs/core/client.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWotchi = createWotchi;
+const config_js_1 = require("./config.js");
+const diagnostics_js_1 = require("./diagnostics.js");
+const fingerprint_js_1 = require("./fingerprint.js");
+const group_store_js_1 = require("./group-store.js");
+const incident_builder_js_1 = require("./incident-builder.js");
+const incident_policy_js_1 = require("./incident-policy.js");
+const normalize_js_1 = require("./normalize.js");
+const notification_queue_js_1 = require("./notification-queue.js");
+const redact_js_1 = require("./redact.js");
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const asString = (value) => typeof value === "string" ? value : undefined;
+const asStatusCode = (value) => typeof value === "number" && Number.isSafeInteger(value) ? value : undefined;
+const safeRecord = (value, privacy) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    const redacted = (0, redact_js_1.redactValue)(value, privacy);
+    return isRecord(redacted) ? redacted : undefined;
+};
+const mergeContext = (metadata, context, privacy) => {
+    if (metadata === undefined && context === undefined) {
+        return undefined;
+    }
+    const metadataValue = safeRecord(metadata, privacy);
+    const contextValue = safeRecord(context, privacy);
+    if (metadataValue === undefined && contextValue === undefined) {
+        return undefined;
+    }
+    return { ...(metadataValue ?? {}), ...(contextValue ?? {}) };
+};
+const safeRequest = (request, privacy) => {
+    if (request === undefined) {
+        return undefined;
+    }
+    const redacted = (0, redact_js_1.redactValue)(request, privacy);
+    if (!isRecord(redacted)) {
+        return undefined;
+    }
+    const method = asString(redacted.method);
+    const route = asString(redacted.route);
+    const requestId = asString(redacted.requestId);
+    const statusCode = asStatusCode(redacted.statusCode);
+    if (method === undefined &&
+        route === undefined &&
+        requestId === undefined &&
+        statusCode === undefined) {
+        return undefined;
+    }
+    return {
+        ...(method === undefined ? {} : { method }),
+        ...(route === undefined ? {} : { route }),
+        ...(requestId === undefined ? {} : { requestId }),
+        ...(statusCode === undefined ? {} : { statusCode }),
+    };
+};
+const safeMessage = (value, privacy) => {
+    const normalized = (0, normalize_js_1.normalizeUnknown)(value, privacy);
+    return typeof normalized === "string" ? normalized : "[unreadable value]";
+};
+function createWotchi(config) {
+    const normalized = (0, config_js_1.validateConfig)(config);
+    const now = Date.now;
+    const groupStore = (0, group_store_js_1.createGroupStore)({
+        maxGroups: normalized.grouping.maxGroups,
+        maxEventsPerWindow: normalized.grouping.maxEventsPerWindow,
+        windowMs: normalized.grouping.windowMs,
+        now,
+    });
+    const diagnostics = (0, diagnostics_js_1.createDiagnosticsState)();
+    const queue = (0, notification_queue_js_1.createNotificationQueue)({
+        maxPendingAlerts: normalized.queue.maxPendingAlerts,
+        concurrency: normalized.queue.concurrency,
+    });
+    const privacy = normalized.privacy;
+    let eventSequence = 0;
+    const captureSafeEvent = (error, metadata, context, request, eventKind = "error") => {
+        const timestamp = now();
+        const safeError = (0, redact_js_1.redactError)((0, normalize_js_1.normalizeError)(error, privacy), privacy);
+        const requestContext = safeRequest(request, privacy);
+        const eventContext = mergeContext(metadata, context, privacy);
+        const safeEvent = {
+            id: `event-${eventSequence + 1}`,
+            timestamp: new Date(timestamp).toISOString(),
+            service: normalized.service,
+            environment: normalized.environment,
+            ...(normalized.release === undefined ? {} : { release: normalized.release }),
+            error: safeError,
+            ...(requestContext === undefined ? {} : { request: requestContext }),
+            ...(eventContext === undefined ? {} : { context: eventContext }),
+        };
+        eventSequence += 1;
+        const fingerprint = (0, fingerprint_js_1.fingerprintSafeErrorEvent)(safeEvent);
+        const group = groupStore.record(fingerprint, safeEvent);
+        const decision = (0, incident_policy_js_1.evaluateIncidentPolicy)({
+            group,
+            now: timestamp,
+            alertThreshold: normalized.grouping.alertThreshold,
+            cooldownMs: normalized.grouping.cooldownMs,
+            eventKind,
+        });
+        if (decision.shouldAlert) {
+            const alert = (0, incident_builder_js_1.buildIncidentAlert)(group, decision);
+            if (queue.enqueue(alert, normalized.notifiers)) {
+                groupStore.markAlerted(fingerprint, timestamp);
+            }
+        }
+        diagnostics.capturedEvents += 1;
+    };
+    const captureException = (error, context) => {
+        if (!normalized.enabled) {
+            return;
+        }
+        try {
+            captureSafeEvent(error, undefined, context, undefined);
+        }
+        catch {
+            diagnostics.captureFailures += 1;
+        }
+    };
+    const captureEvent = (event) => {
+        if (!normalized.enabled) {
+            return;
+        }
+        try {
+            if (event === null || typeof event !== "object" || event.level !== "error") {
+                throw new TypeError("event.level must be error");
+            }
+            if (typeof event.message !== "string") {
+                throw new TypeError("event.message must be a string");
+            }
+            captureSafeEvent(event.error ?? safeMessage(event.message, privacy), event.metadata, event.context, event.request, event.kind ?? "error");
+        }
+        catch {
+            diagnostics.captureFailures += 1;
+        }
+    };
+    return {
+        captureException,
+        captureEvent,
+        flush: (timeoutMs) => queue.flush(timeoutMs),
+        getDiagnostics: () => (0, diagnostics_js_1.snapshotDiagnostics)(diagnostics, {
+            groupsEvicted: groupStore.groupsEvicted(),
+            alertsQueued: queue.alertsQueued(),
+            alertsDropped: queue.alertsDropped(),
+            alertsSent: queue.alertsSent(),
+            notifierFailures: queue.notifierFailures(),
+            activeGroups: groupStore.size(),
+            pendingAlerts: queue.pending(),
+        }),
+    };
+}

package/dist/cjs/core/config.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WotchiConfigurationError = void 0;
+exports.validateConfig = validateConfig;
+const errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "WotchiConfigurationError", { enumerable: true, get: function () { return errors_js_1.WotchiConfigurationError; } });
+const MAX_REDACT_KEYS = 100;
+const isRecord = (value) => typeof value === "object" && value !== null;
+const fail = (field) => {
+    throw new errors_js_1.WotchiConfigurationError(`${field} is invalid`);
+};
+const readPositiveInteger = (parent, field, defaultValue) => {
+    const value = parent?.[field];
+    if (value === undefined) {
+        return defaultValue;
+    }
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
+        return fail(field);
+    }
+    return value;
+};
+const readOptionalRecord = (value, field) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!isRecord(value)) {
+        return fail(field);
+    }
+    return value;
+};
+const normalizeRedactKeys = (privacy) => {
+    const value = privacy?.redactKeys;
+    if (value === undefined) {
+        return Object.freeze([]);
+    }
+    if (!Array.isArray(value) || value.length > MAX_REDACT_KEYS) {
+        return fail("privacy.redactKeys");
+    }
+    const keys = value.map((key, index) => {
+        if (typeof key !== "string" || key.trim().length === 0) {
+            return fail(`privacy.redactKeys[${index}]`);
+        }
+        return key.trim();
+    });
+    return Object.freeze([...new Set(keys)]);
+};
+const normalizeNotifiers = (value) => {
+    if (!Array.isArray(value) || value.length === 0) {
+        return fail("notifiers");
+    }
+    for (let index = 0; index < value.length; index += 1) {
+        const notifier = value[index];
+        if (!isRecord(notifier) ||
+            typeof notifier.name !== "string" ||
+            notifier.name.trim().length === 0 ||
+            typeof notifier.send !== "function") {
+            return fail(`notifiers[${index}]`);
+        }
+    }
+    return Object.freeze([...value]);
+};
+function validateConfig(config) {
+    if (!isRecord(config)) {
+        return fail("config");
+    }
+    const service = config.service;
+    if (typeof service !== "string" || service.trim().length === 0) {
+        return fail("service");
+    }
+    const environment = config.environment;
+    if (typeof environment !== "string" || environment.trim().length === 0) {
+        return fail("environment");
+    }
+    if (config.release !== undefined &&
+        (typeof config.release !== "string" || config.release.trim().length === 0)) {
+        return fail("release");
+    }
+    if (config.enabled !== undefined && typeof config.enabled !== "boolean") {
+        return fail("enabled");
+    }
+    const grouping = readOptionalRecord(config.grouping, "grouping");
+    const queue = readOptionalRecord(config.queue, "queue");
+    const privacy = readOptionalRecord(config.privacy, "privacy");
+    const concurrency = queue?.concurrency;
+    if (concurrency !== undefined && concurrency !== 1) {
+        return fail("queue.concurrency");
+    }
+    const normalized = {
+        service: service.trim(),
+        environment: environment.trim(),
+        ...(config.release === undefined ? {} : { release: config.release.trim() }),
+        enabled: config.enabled ?? true,
+        grouping: Object.freeze({
+            windowMs: readPositiveInteger(grouping, "windowMs", 60_000),
+            alertThreshold: readPositiveInteger(grouping, "alertThreshold", 3),
+            cooldownMs: readPositiveInteger(grouping, "cooldownMs", 900_000),
+            maxGroups: readPositiveInteger(grouping, "maxGroups", 200),
+            maxEventsPerWindow: readPositiveInteger(grouping, "maxEventsPerWindow", 100),
+        }),
+        queue: Object.freeze({
+            maxPendingAlerts: readPositiveInteger(queue, "maxPendingAlerts", 100),
+            concurrency: 1,
+        }),
+        privacy: Object.freeze({
+            redactKeys: normalizeRedactKeys(privacy),
+            maxDepth: readPositiveInteger(privacy, "maxDepth", 5),
+            maxKeys: readPositiveInteger(privacy, "maxKeys", 100),
+            maxStringLength: readPositiveInteger(privacy, "maxStringLength", 500),
+            maxStackLength: readPositiveInteger(privacy, "maxStackLength", 4_000),
+        }),
+        notifiers: normalizeNotifiers(config.notifiers),
+    };
+    return Object.freeze(normalized);
+}

package/dist/cjs/core/diagnostics.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDiagnosticsState = createDiagnosticsState;
+exports.snapshotDiagnostics = snapshotDiagnostics;
+function createDiagnosticsState() {
+    return { capturedEvents: 0, captureFailures: 0 };
+}
+function snapshotDiagnostics(state, values) {
+    return Object.freeze({
+        capturedEvents: state.capturedEvents,
+        captureFailures: state.captureFailures,
+        ...values,
+    });
+}

package/dist/cjs/core/errors.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WotchiConfigurationError = void 0;
+class WotchiConfigurationError extends Error {
+    constructor(message) {
+        super(`Invalid Wotchi configuration: ${message}`);
+        this.name = "WotchiConfigurationError";
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.WotchiConfigurationError = WotchiConfigurationError;