@msg91comm/m91 0.0.0-stage → 1.1.0

package/dist/src/http.js

@@ -0,0 +1,150 @@
+/**
+ * HTTP on native `fetch`, with the retry policy applied. Zero dependencies.
+ *
+ * The rules, which are the interesting part:
+ *
+ * - **429 is retried exactly once**, after exactly the delay the server asked
+ *   for. The send limit is 60/minute per link and every 429 carries
+ *   `Retry-After: 60`. Retrying a second time would be arguing with it.
+ * - **5xx is retried with backoff.** Not the caller's fault, and the alert has
+ *   not been raised, so repeating it cannot double-page anybody.
+ * - **4xx is never retried.** Not transient; the next identical request fails
+ *   identically.
+ * - **A network failure is never retried.** A send that timed out may or may not
+ *   have raised the alert — the response is what was lost, not necessarily the
+ *   request. Blind retries are how one condition wakes a team four times.
+ */
+import { M91NetworkError, retryAfter, unwrap } from './exceptions.js';
+export const USER_AGENT = 'm91-node/1.0.0';
+/** Delays before the 2nd, 3rd and 4th attempt at a 5xx. Four requests total. */
+export const SERVER_BACKOFF = [1000, 2000, 4000];
+export const RETRYABLE_STATUSES = new Set([500, 502, 503, 504]);
+/**
+ * A 429 whose `Retry-After` is longer than this is thrown rather than slept
+ * through. The server sends 60; anything far past that is a caller sitting
+ * blocked in an alerting path, which is worse than an error it can see.
+ */
+export const MAX_RETRY_AFTER_MS = 120_000;
+/**
+ * Milliseconds to wait before trying again, or `null` to stop and throw.
+ * `attempt` is 1-based and counts requests already made.
+ */
+export function retryDelay(status, attempt, retryAfterSeconds) {
+    if (status === 429) {
+        // Once, and only on the first 429. A second means the window has not
+        // actually cleared and the caller needs to hear about it.
+        if (attempt >= 2)
+            return null;
+        const wait = (retryAfterSeconds ?? 60) * 1000;
+        return wait > MAX_RETRY_AFTER_MS ? null : Math.max(wait, 0);
+    }
+    if (RETRYABLE_STATUSES.has(status)) {
+        return attempt > SERVER_BACKOFF.length ? null : SERVER_BACKOFF[attempt - 1];
+    }
+    return null;
+}
+/**
+ * Matches a send link anywhere — in a bare URL, or buried in a sentence — and
+ * takes any query string attached to it. Bounded on whitespace so it stops at
+ * the end of the URL rather than eating the rest of the message.
+ */
+const SEND_URL_RE = /(\/s\/)[^\s/?#]+(\?[^\s]*)?/g;
+/**
+ * Replace a send link's token with `***`, wherever it appears.
+ *
+ * **The token is the credential and it lives in the path**, so a URL is as
+ * sensitive as a password and must never reach a log, an error message or a
+ * stack trace intact. The server holds itself to the same rule — its error
+ * handler reports the route *pattern*, never `req.path`.
+ *
+ * This takes free text, not only a URL, and that is the point. Redacting only
+ * the URL the SDK interpolates is not enough: a fetch failure can carry the URL
+ * in its own message, so a carefully-redacted sentence would arrive with the
+ * raw token attached to it by the runtime.
+ *
+ * Query strings go too: a GET-form send carries the alert title, and titles
+ * routinely name customers and hosts.
+ */
+export function redact(text) {
+    if (typeof text !== 'string')
+        return text;
+    return text.replace(SEND_URL_RE, '$1***');
+}
+const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+export class Transport {
+    timeoutMs;
+    headers;
+    fetchImpl;
+    sleepImpl;
+    constructor(options = {}) {
+        this.timeoutMs = options.timeoutMs ?? 15_000;
+        this.headers = {
+            // A GET-form send answers with a rendered HTML page when the caller looks
+            // like a browser. That page exists so a person tapping a bookmark sees
+            // something other than a wall of JSON — but an SDK is not a person, and
+            // has to opt out of it explicitly.
+            accept: 'application/json',
+            'user-agent': USER_AGENT,
+            ...options.headers,
+        };
+        this.fetchImpl = options.fetchImpl ?? globalThis.fetch;
+        this.sleepImpl = options.sleepImpl ?? defaultSleep;
+    }
+    async request({ method, url, body, query }) {
+        const target = query ? `${url}?${new URLSearchParams(query).toString()}` : url;
+        let attempt = 0;
+        for (;;) {
+            attempt += 1;
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+            let status;
+            let headers;
+            let parsed;
+            try {
+                const response = await this.fetchImpl(target, {
+                    method,
+                    headers: body === undefined
+                        ? this.headers
+                        : { ...this.headers, 'content-type': 'application/json' },
+                    body: body === undefined ? undefined : JSON.stringify(body),
+                    signal: controller.signal,
+                });
+                status = response.status;
+                headers = response.headers;
+                parsed = await readBody(response);
+            }
+            catch (error) {
+                // Redacted AFTER composing, not before: a fetch failure can name the
+                // URL in its own message, so masking only our half still ships the token.
+                const reason = error instanceof Error ? error.message : String(error);
+                throw new M91NetworkError(redact(`Could not reach M91 at ${target}: ${reason}`));
+            }
+            finally {
+                clearTimeout(timer);
+            }
+            const delay = retryDelay(status, attempt, retryAfter(headers));
+            if (delay === null)
+                return unwrap(status, parsed, headers);
+            await this.sleepImpl(delay);
+        }
+    }
+}
+/**
+ * The parsed envelope, or something `unwrap` can still turn into an error.
+ *
+ * A non-JSON body here means a proxy, a load balancer or an HTML error page
+ * answered instead of M91. Wrapping the text in an envelope-shaped object keeps
+ * all the error construction in one place rather than adding a second path.
+ */
+async function readBody(response) {
+    const text = await response.text();
+    if (!text)
+        return { error: { message: `HTTP ${response.status} with an empty body` } };
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return { error: { message: text.slice(0, 300) } };
+    }
+}
+//# sourceMappingURL=http.js.map

package/dist/src/http.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.js","sourceRoot":"","sources":["../../src/http.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEtE,MAAM,CAAC,MAAM,UAAU,GAAG,gBAAgB,CAAC;AAE3C,gFAAgF;AAChF,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAU,CAAC;AAE1D,MAAM,CAAC,MAAM,kBAAkB,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;AAEhE;;;;GAIG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,OAAO,CAAC;AAE1C;;;GAGG;AACH,MAAM,UAAU,UAAU,CAAC,MAAc,EAAE,OAAe,EAAE,iBAA0B;IACpF,IAAI,MAAM,KAAK,GAAG,EAAE,CAAC;QACnB,qEAAqE;QACrE,0DAA0D;QAC1D,IAAI,OAAO,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC;QAC9B,MAAM,IAAI,GAAG,CAAC,iBAAiB,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;QAC9C,OAAO,IAAI,GAAG,kBAAkB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IAC9D,CAAC;IACD,IAAI,kBAAkB,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;QACnC,OAAO,OAAO,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,cAAc,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC;IAC9E,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;GAIG;AACH,MAAM,WAAW,GAAG,8BAA8B,CAAC;AAEnD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,MAAM,CAAC,IAAY;IACjC,IAAI,OAAO,IAAI,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC;IAC1C,OAAO,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;AAC5C,CAAC;AAkBD,MAAM,YAAY,GAAG,CAAC,EAAU,EAAE,EAAE,CAAC,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;AAE7F,MAAM,OAAO,SAAS;IACH,SAAS,CAAS;IAClB,OAAO,CAAyB;IAChC,SAAS,CAAe;IACxB,SAAS,CAAgC;IAE1D,YAAY,UAA4B,EAAE;QACxC,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,MAAM,CAAC;QAC7C,IAAI,CAAC,OAAO,GAAG;YACb,0EAA0E;YAC1E,uEAAuE;YACvE,wEAAwE;YACxE,mCAAmC;YACnC,MAAM,EAAE,kBAAkB;YAC1B,YAAY,EAAE,UAAU;YACxB,GAAG,OAAO,CAAC,OAAO;SACnB,CAAC;QACF,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,UAAU,CAAC,KAAK,CAAC;QACvD,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,YAAY,CAAC;IACrD,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,KAAK,EAAkB;QACxD,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,GAAG,IAAI,IAAI,eAAe,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC;QAC/E,IAAI,OAAO,GAAG,CAAC,CAAC;QAEhB,SAAS,CAAC;YACR,OAAO,IAAI,CAAC,CAAC;YACb,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;YACzC,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,KAAK,EAAE,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;YAEnE,IAAI,MAAc,CAAC;YACnB,IAAI,OAAgB,CAAC;YACrB,IAAI,MAAe,CAAC;YACpB,IAAI,CAAC;gBACH,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE;oBAC5C,MAAM;oBACN,OAAO,EAAE,IAAI,KAAK,SAAS;wBACzB,CAAC,CAAC,IAAI,CAAC,OAAO;wBACd,CAAC,CAAC,EAAE,GAAG,IAAI,CAAC,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE;oBAC3D,IAAI,EAAE,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;oBAC3D,MAAM,EAAE,UAAU,CAAC,MAAM;iBAC1B,CAAC,CAAC;gBACH,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC;gBACzB,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC;gBAC3B,MAAM,GAAG,MAAM,QAAQ,CAAC,QAAQ,CAAC,CAAC;YACpC,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,qEAAqE;gBACrE,0EAA0E;gBAC1E,MAAM,MAAM,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;gBACtE,MAAM,IAAI,eAAe,CAAC,MAAM,CAAC,0BAA0B,MAAM,KAAK,MAAM,EAAE,CAAC,CAAC,CAAC;YACnF,CAAC;oBAAS,CAAC;gBACT,YAAY,CAAC,KAAK,CAAC,CAAC;YACtB,CAAC;YAED,MAAM,KAAK,GAAG,UAAU,CAAC,MAAM,EAAE,OAAO,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC;YAC/D,IAAI,KAAK,KAAK,IAAI;gBAAE,OAAO,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;YAC3D,MAAM,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QAC9B,CAAC;IACH,CAAC;CACF;AAED;;;;;;GAMG;AACH,KAAK,UAAU,QAAQ,CAAC,QAAkB;IACxC,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;IACnC,IAAI,CAAC,IAAI;QAAE,OAAO,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,QAAQ,QAAQ,CAAC,MAAM,qBAAqB,EAAE,EAAE,CAAC;IACvF,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC;IACpD,CAAC;AACH,CAAC"}

package/dist/src/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * M91 — wake a human when software cannot carry on alone.
+ *
+ * An alert rings every phone in a channel at full volume, through silent mode
+ * and Do Not Disturb, and keeps ringing until somebody answers. HIGH and
+ * CRITICAL place a voice call if 45 seconds pass with no answer. Whoever takes
+ * it on is recorded, and it clears for everyone else.
+ *
+ * ```ts
+ * import { M91Client } from '@msg91comm/m91';
+ *
+ * const m91 = new M91Client(process.env.M91_SEND_LINK!);
+ * await m91.verify();                              // raises nothing; names the channel
+ * await m91.send('Payments API is down', { severity: 'CRITICAL', customId: 'payments-down' });
+ * await m91.close({ customId: 'payments-down' });
+ * ```
+ *
+ * And the reason an agent wants it — a question that blocks until a person
+ * answers on their phone:
+ *
+ * ```ts
+ * if (await m91.requestApproval('Refund 48,000 on ORD-40122?', { customId: 'refund-ORD-40122' })) {
+ *   await processRefund();
+ * }
+ * ```
+ *
+ * Everything here is a convenience over one URL. The send link works from a
+ * browser bar, a cron `curl` or an `<img>` tag with no client at all, and
+ * `M91URLBuilder` is for exactly those.
+ */
+export { M91Client } from './client.js';
+export type { ApprovalOptions, ClientOptions, SendOptions, WaitOptions } from './client.js';
+export { M91Platform, DEFAULT_BASE_URL } from './platform.js';
+export type { PlatformOptions } from './platform.js';
+export { M91URLBuilder, normalizeSendLink } from './url-builder.js';
+export type { BuildManySpec, BuildUrlOptions } from './url-builder.js';
+export { redact } from './http.js';
+export { M91Error, M91ValidationError, M91AuthError, M91ForbiddenError, M91NotFoundError, M91ChannelEmptyError, M91RateLimitError, M91ServerError, M91NetworkError, M91DeliveryError, M91TimeoutError, } from './exceptions.js';
+export { SEVERITIES, EFFECTS, ESCALATING_SEVERITIES, isApproved, validatePhone, buildAlertPayload, } from './models.js';
+export type { AlertDetail, AlertResponse, AlertStatus, ApiKeyInfo, ChannelInfo, Attachment, Decision, Response, Effect, InviteResult, ProvisionedChannel, Recipient, RecipientState, ResponseOption, Severity, } from './models.js';
+/**
+ * Kept in step with package.json by `tests/version.test.ts`, not by hand.
+ *
+ * ESM has no portable way to read package.json at runtime, so this number is
+ * written twice — and it drifted, reporting 1.0.0 while the package shipped as
+ * 1.1.0. A test is what makes two copies safe.
+ */
+export declare const VERSION = "1.1.0";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE5F,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAC9D,YAAY,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACpE,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEvE,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnC,OAAO,EACL,QAAQ,EACR,kBAAkB,EAClB,YAAY,EACZ,iBAAiB,EACjB,gBAAgB,EAChB,oBAAoB,EACpB,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,eAAe,GAChB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACL,UAAU,EACV,OAAO,EACP,qBAAqB,EACrB,UAAU,EACV,aAAa,EACb,iBAAiB,GAClB,MAAM,aAAa,CAAC;AAErB,YAAY,EACV,WAAW,EACX,aAAa,EACb,WAAW,EACX,UAAU,EACV,WAAW,EACX,UAAU,EACV,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,YAAY,EACZ,kBAAkB,EAClB,SAAS,EACT,cAAc,EACd,cAAc,EACd,QAAQ,GACT,MAAM,aAAa,CAAC;AAErB;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,UAAU,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,45 @@
+/**
+ * M91 — wake a human when software cannot carry on alone.
+ *
+ * An alert rings every phone in a channel at full volume, through silent mode
+ * and Do Not Disturb, and keeps ringing until somebody answers. HIGH and
+ * CRITICAL place a voice call if 45 seconds pass with no answer. Whoever takes
+ * it on is recorded, and it clears for everyone else.
+ *
+ * ```ts
+ * import { M91Client } from '@msg91comm/m91';
+ *
+ * const m91 = new M91Client(process.env.M91_SEND_LINK!);
+ * await m91.verify();                              // raises nothing; names the channel
+ * await m91.send('Payments API is down', { severity: 'CRITICAL', customId: 'payments-down' });
+ * await m91.close({ customId: 'payments-down' });
+ * ```
+ *
+ * And the reason an agent wants it — a question that blocks until a person
+ * answers on their phone:
+ *
+ * ```ts
+ * if (await m91.requestApproval('Refund 48,000 on ORD-40122?', { customId: 'refund-ORD-40122' })) {
+ *   await processRefund();
+ * }
+ * ```
+ *
+ * Everything here is a convenience over one URL. The send link works from a
+ * browser bar, a cron `curl` or an `<img>` tag with no client at all, and
+ * `M91URLBuilder` is for exactly those.
+ */
+export { M91Client } from './client.js';
+export { M91Platform, DEFAULT_BASE_URL } from './platform.js';
+export { M91URLBuilder, normalizeSendLink } from './url-builder.js';
+export { redact } from './http.js';
+export { M91Error, M91ValidationError, M91AuthError, M91ForbiddenError, M91NotFoundError, M91ChannelEmptyError, M91RateLimitError, M91ServerError, M91NetworkError, M91DeliveryError, M91TimeoutError, } from './exceptions.js';
+export { SEVERITIES, EFFECTS, ESCALATING_SEVERITIES, isApproved, validatePhone, buildAlertPayload, } from './models.js';
+/**
+ * Kept in step with package.json by `tests/version.test.ts`, not by hand.
+ *
+ * ESM has no portable way to read package.json at runtime, so this number is
+ * written twice — and it drifted, reporting 1.0.0 while the package shipped as
+ * 1.1.0. A test is what makes two copies safe.
+ */
+export const VERSION = '1.1.0';
+//# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGxC,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAG9D,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAGpE,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnC,OAAO,EACL,QAAQ,EACR,kBAAkB,EAClB,YAAY,EACZ,iBAAiB,EACjB,gBAAgB,EAChB,oBAAoB,EACpB,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,eAAe,GAChB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACL,UAAU,EACV,OAAO,EACP,qBAAqB,EACrB,UAAU,EACV,aAAa,EACb,iBAAiB,GAClB,MAAM,aAAa,CAAC;AAoBrB;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,OAAO,CAAC"}

package/dist/src/integrations/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Framework adapters, re-exported.
+ *
+ * Each one imports its framework lazily, so `npm install @msg91comm/m91` pulls in none of
+ * them and using one you have not installed says which package to install
+ * rather than failing with a bare module-not-found from three frames down.
+ *
+ * Importing a specific adapter directly is usually better —
+ * `@msg91comm/m91/integrations/langchain` — because it pulls in only what you use.
+ *
+ * `langchain.ts` and `vercel-ai.ts` both export `createM91ApprovalTool`, so
+ * they are re-exported under namespaces rather than flattened: two functions of
+ * the same name doing the same job for different frameworks is exactly the pair
+ * that would silently resolve to the wrong one.
+ */
+export * as langchain from './langchain.js';
+export * as langgraph from './langgraph.js';
+export * as vercelAi from './vercel-ai.js';
+export { M91InterruptNotifier, createM91ApprovalNode } from './langgraph.js';
+export { APPROVED, REJECTED, alertResult, errorResult } from './specs.js';
+export type { AlertArgs, ApprovalArgs } from './specs.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/integrations/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/integrations/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAE3C,OAAO,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAC7E,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC1E,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC"}

package/dist/src/integrations/index.js

@@ -0,0 +1,21 @@
+/**
+ * Framework adapters, re-exported.
+ *
+ * Each one imports its framework lazily, so `npm install @msg91comm/m91` pulls in none of
+ * them and using one you have not installed says which package to install
+ * rather than failing with a bare module-not-found from three frames down.
+ *
+ * Importing a specific adapter directly is usually better —
+ * `@msg91comm/m91/integrations/langchain` — because it pulls in only what you use.
+ *
+ * `langchain.ts` and `vercel-ai.ts` both export `createM91ApprovalTool`, so
+ * they are re-exported under namespaces rather than flattened: two functions of
+ * the same name doing the same job for different frameworks is exactly the pair
+ * that would silently resolve to the wrong one.
+ */
+export * as langchain from './langchain.js';
+export * as langgraph from './langgraph.js';
+export * as vercelAi from './vercel-ai.js';
+export { M91InterruptNotifier, createM91ApprovalNode } from './langgraph.js';
+export { APPROVED, REJECTED, alertResult, errorResult } from './specs.js';
+//# sourceMappingURL=index.js.map

package/dist/src/integrations/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/integrations/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAE3C,OAAO,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAC7E,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC"}

package/dist/src/integrations/langchain.d.ts

@@ -0,0 +1,43 @@
+/**
+ * LangChain tools.
+ *
+ * Two of them, and the split matters more than it looks:
+ *
+ * - the approval tool **blocks**. The agent stops until a human answers on
+ *   their phone. Give it to an agent that can do something irreversible.
+ * - the alert tool does not. It wakes somebody and carries on.
+ *
+ * ```ts
+ * import { M91Client } from '@msg91comm/m91';
+ * import { createM91ApprovalTool, createM91AlertTool } from '@msg91comm/m91/integrations/langchain';
+ *
+ * const client = new M91Client(process.env.M91_SEND_LINK!);
+ * const tools = [
+ *   await createM91ApprovalTool(client),
+ *   await createM91AlertTool(client),
+ *   ...myTools,
+ * ];
+ * const agent = createReactAgent({ llm, tools });
+ * ```
+ *
+ * The factories are **async** because `@langchain/core` is an optional peer
+ * dependency, imported only when one of these is called. That keeps `npm
+ * install @msg91comm/m91` at zero dependencies, which matters for a package whose job is
+ * to work when everything else is on fire.
+ */
+import type { M91Client } from '../client.js';
+import { type AlertDefaults, type ApprovalDefaults } from './specs.js';
+/**
+ * The blocking approval gate, as a LangChain tool named `m91_request_approval`.
+ * Returns `"approved"`, `"rejected"` or `"error: …"` — and nothing but a real
+ * human approval returns `"approved"`.
+ */
+export declare function createM91ApprovalTool(client: M91Client, defaults?: ApprovalDefaults): Promise<unknown>;
+/**
+ * The fire-and-forget alert, as a LangChain tool named `m91_send_alert`.
+ * Returns `"sent:delivered=N"` or `"error: …"`.
+ */
+export declare function createM91AlertTool(client: M91Client, defaults?: AlertDefaults): Promise<unknown>;
+/** Both, in the order an agent's `tools` array usually wants them. */
+export declare function createM91Tools(client: M91Client, defaults?: ApprovalDefaults & AlertDefaults): Promise<unknown[]>;
+//# sourceMappingURL=langchain.d.ts.map

package/dist/src/integrations/langchain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"langchain.d.ts","sourceRoot":"","sources":["../../../src/integrations/langchain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAQL,KAAK,aAAa,EAElB,KAAK,gBAAgB,EAGtB,MAAM,YAAY,CAAC;AAmBpB;;;;GAIG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,SAAS,EACjB,QAAQ,GAAE,gBAAqB,GAC9B,OAAO,CAAC,OAAO,CAAC,CAOlB;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,SAAS,EACjB,QAAQ,GAAE,aAAkB,GAC3B,OAAO,CAAC,OAAO,CAAC,CAOlB;AAED,sEAAsE;AACtE,wBAAsB,cAAc,CAClC,MAAM,EAAE,SAAS,EACjB,QAAQ,GAAE,gBAAgB,GAAG,aAAkB,GAC9C,OAAO,CAAC,OAAO,EAAE,CAAC,CAKpB"}

package/dist/src/integrations/langchain.js

@@ -0,0 +1,75 @@
+/**
+ * LangChain tools.
+ *
+ * Two of them, and the split matters more than it looks:
+ *
+ * - the approval tool **blocks**. The agent stops until a human answers on
+ *   their phone. Give it to an agent that can do something irreversible.
+ * - the alert tool does not. It wakes somebody and carries on.
+ *
+ * ```ts
+ * import { M91Client } from '@msg91comm/m91';
+ * import { createM91ApprovalTool, createM91AlertTool } from '@msg91comm/m91/integrations/langchain';
+ *
+ * const client = new M91Client(process.env.M91_SEND_LINK!);
+ * const tools = [
+ *   await createM91ApprovalTool(client),
+ *   await createM91AlertTool(client),
+ *   ...myTools,
+ * ];
+ * const agent = createReactAgent({ llm, tools });
+ * ```
+ *
+ * The factories are **async** because `@langchain/core` is an optional peer
+ * dependency, imported only when one of these is called. That keeps `npm
+ * install @msg91comm/m91` at zero dependencies, which matters for a package whose job is
+ * to work when everything else is on fire.
+ */
+import { ALERT_DESCRIPTION, ALERT_SCHEMA, ALERT_TOOL_NAME, APPROVAL_DESCRIPTION, APPROVAL_SCHEMA, APPROVAL_TOOL_NAME, runAlert, runApproval, } from './specs.js';
+async function langchainTool() {
+    try {
+        // The specifier is a variable so TypeScript does not try to resolve an
+        // optional peer dependency at build time. Compiling this package must not
+        // require every framework it can adapt to.
+        const specifier = '@langchain/core/tools';
+        const mod = (await import(specifier));
+        return mod.tool;
+    }
+    catch (error) {
+        throw new Error('The LangChain integration needs @langchain/core. Install it with: ' +
+            'npm install @langchain/core', { cause: error });
+    }
+}
+/**
+ * The blocking approval gate, as a LangChain tool named `m91_request_approval`.
+ * Returns `"approved"`, `"rejected"` or `"error: …"` — and nothing but a real
+ * human approval returns `"approved"`.
+ */
+export async function createM91ApprovalTool(client, defaults = {}) {
+    const tool = await langchainTool();
+    return tool((args) => runApproval(client, args, defaults), {
+        name: APPROVAL_TOOL_NAME,
+        description: APPROVAL_DESCRIPTION,
+        schema: APPROVAL_SCHEMA,
+    });
+}
+/**
+ * The fire-and-forget alert, as a LangChain tool named `m91_send_alert`.
+ * Returns `"sent:delivered=N"` or `"error: …"`.
+ */
+export async function createM91AlertTool(client, defaults = {}) {
+    const tool = await langchainTool();
+    return tool((args) => runAlert(client, args, defaults), {
+        name: ALERT_TOOL_NAME,
+        description: ALERT_DESCRIPTION,
+        schema: ALERT_SCHEMA,
+    });
+}
+/** Both, in the order an agent's `tools` array usually wants them. */
+export async function createM91Tools(client, defaults = {}) {
+    return [
+        await createM91ApprovalTool(client, defaults),
+        await createM91AlertTool(client, defaults),
+    ];
+}
+//# sourceMappingURL=langchain.js.map

package/dist/src/integrations/langchain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"langchain.js","sourceRoot":"","sources":["../../../src/integrations/langchain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,EACL,iBAAiB,EACjB,YAAY,EACZ,eAAe,EACf,oBAAoB,EACpB,eAAe,EACf,kBAAkB,EAKlB,QAAQ,EACR,WAAW,GACZ,MAAM,YAAY,CAAC;AAEpB,KAAK,UAAU,aAAa;IAC1B,IAAI,CAAC;QACH,uEAAuE;QACvE,0EAA0E;QAC1E,2CAA2C;QAC3C,MAAM,SAAS,GAAG,uBAAuB,CAAC;QAC1C,MAAM,GAAG,GAAG,CAAC,MAAM,MAAM,CAAC,SAAS,CAAC,CAAwD,CAAC;QAC7F,OAAO,GAAG,CAAC,IAAI,CAAC;IAClB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CACb,oEAAoE;YAClE,6BAA6B,EAC/B,EAAE,KAAK,EAAE,KAAK,EAAE,CACjB,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,MAAiB,EACjB,WAA6B,EAAE;IAE/B,MAAM,IAAI,GAAG,MAAM,aAAa,EAAE,CAAC;IACnC,OAAO,IAAI,CAAC,CAAC,IAAkB,EAAE,EAAE,CAAC,WAAW,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,EAAE;QACvE,IAAI,EAAE,kBAAkB;QACxB,WAAW,EAAE,oBAAoB;QACjC,MAAM,EAAE,eAAe;KACxB,CAAC,CAAC;AACL,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,MAAiB,EACjB,WAA0B,EAAE;IAE5B,MAAM,IAAI,GAAG,MAAM,aAAa,EAAE,CAAC;IACnC,OAAO,IAAI,CAAC,CAAC,IAAe,EAAE,EAAE,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,EAAE;QACjE,IAAI,EAAE,eAAe;QACrB,WAAW,EAAE,iBAAiB;QAC9B,MAAM,EAAE,YAAY;KACrB,CAAC,CAAC;AACL,CAAC;AAED,sEAAsE;AACtE,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,MAAiB,EACjB,WAA6C,EAAE;IAE/C,OAAO;QACL,MAAM,qBAAqB,CAAC,MAAM,EAAE,QAAQ,CAAC;QAC7C,MAAM,kBAAkB,CAAC,MAAM,EAAE,QAAQ,CAAC;KAC3C,CAAC;AACJ,CAAC"}

package/dist/src/integrations/langgraph.d.ts

@@ -0,0 +1,79 @@
+/**
+ * LangGraph helpers for the `interrupt()` pattern.
+ *
+ * LangGraph already knows how to stop a graph and resume it. What it has no
+ * opinion about is **how the human finds out it stopped** — and the default
+ * answer is that somebody notices a paused run in a web UI. At 2am, for a graph
+ * that paused because it wants to move money, nobody does. M91 fills exactly
+ * that gap: the graph pauses, a phone rings until somebody answers, and the
+ * answer resumes the graph.
+ *
+ * Nothing here imports `@langchain/langgraph`. These are plain callables you use
+ * *around* your graph, so they work the same with `interrupt()`, with
+ * `new Command({ resume })`, or with a node you wrote by hand.
+ */
+import type { M91Client } from '../client.js';
+import type { Severity } from '../models.js';
+import { APPROVED, REJECTED } from './specs.js';
+export interface NotifyOptions {
+    title: string;
+    customId: string;
+    description?: string;
+    severity?: Severity;
+    approveLabel?: string;
+    rejectLabel?: string;
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+}
+export type NotifyDefaults = Omit<NotifyOptions, 'title' | 'customId'>;
+export type Verdict = typeof APPROVED | typeof REJECTED;
+/**
+ * Wake a human about an interrupted graph and return what they said.
+ *
+ * ```ts
+ * const notifier = new M91InterruptNotifier(client);
+ *
+ * const result = await graph.invoke(state, config);
+ * if (result.__interrupt__) {
+ *   const data = result.__interrupt__[0].value;
+ *   const decision = await notifier.notify({
+ *     title: data.question,
+ *     customId: data.customId,
+ *     timeoutMs: 600_000,
+ *   });
+ *   await graph.invoke(new Command({ resume: decision }), config);
+ * }
+ * ```
+ *
+ * Resolves `"approved"` or `"rejected"` and **never anything else** — a failure
+ * to reach anybody comes back as `"rejected"`, because a graph that resumes
+ * with an ambiguous value resumes with whatever the node's `if` happens to do
+ * with it.
+ */
+export declare class M91InterruptNotifier {
+    private readonly client;
+    private readonly defaults;
+    constructor(client: M91Client, defaults?: NotifyDefaults);
+    notify(options: NotifyOptions): Promise<Verdict>;
+}
+/**
+ * Build a graph node that asks a human and writes the answer into state.
+ *
+ * ```ts
+ * builder.addNode('humanApproval', createM91ApprovalNode(client, {
+ *   approveLabel: 'Deploy Now',
+ *   rejectLabel: 'Hold Release',
+ *   timeoutMs: 600_000,
+ * }));
+ * ```
+ *
+ * The node reads `title` (or `question`) and `customId` from state and returns
+ * `{ decision, approved }` for the next edge to branch on. Anything passed here
+ * is a default the state can override per run.
+ */
+export declare function createM91ApprovalNode(client: M91Client, defaults?: NotifyDefaults): (state: unknown) => Promise<{
+    decision: Verdict;
+    approved: boolean;
+    error?: string;
+}>;
+//# sourceMappingURL=langgraph.d.ts.map

package/dist/src/integrations/langgraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"langgraph.d.ts","sourceRoot":"","sources":["../../../src/integrations/langgraph.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEhD,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,MAAM,cAAc,GAAG,IAAI,CAAC,aAAa,EAAE,OAAO,GAAG,UAAU,CAAC,CAAC;AAEvE,MAAM,MAAM,OAAO,GAAG,OAAO,QAAQ,GAAG,OAAO,QAAQ,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAY;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAiB;gBAE9B,MAAM,EAAE,SAAS,EAAE,QAAQ,GAAE,cAAmB;IAKtD,MAAM,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC;CAkBvD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,SAAS,EACjB,QAAQ,GAAE,cAAmB,GAC5B,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;IAAE,QAAQ,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAgCvF"}

package/dist/src/integrations/langgraph.js

@@ -0,0 +1,114 @@
+/**
+ * LangGraph helpers for the `interrupt()` pattern.
+ *
+ * LangGraph already knows how to stop a graph and resume it. What it has no
+ * opinion about is **how the human finds out it stopped** — and the default
+ * answer is that somebody notices a paused run in a web UI. At 2am, for a graph
+ * that paused because it wants to move money, nobody does. M91 fills exactly
+ * that gap: the graph pauses, a phone rings until somebody answers, and the
+ * answer resumes the graph.
+ *
+ * Nothing here imports `@langchain/langgraph`. These are plain callables you use
+ * *around* your graph, so they work the same with `interrupt()`, with
+ * `new Command({ resume })`, or with a node you wrote by hand.
+ */
+import { APPROVED, REJECTED } from './specs.js';
+/**
+ * Wake a human about an interrupted graph and return what they said.
+ *
+ * ```ts
+ * const notifier = new M91InterruptNotifier(client);
+ *
+ * const result = await graph.invoke(state, config);
+ * if (result.__interrupt__) {
+ *   const data = result.__interrupt__[0].value;
+ *   const decision = await notifier.notify({
+ *     title: data.question,
+ *     customId: data.customId,
+ *     timeoutMs: 600_000,
+ *   });
+ *   await graph.invoke(new Command({ resume: decision }), config);
+ * }
+ * ```
+ *
+ * Resolves `"approved"` or `"rejected"` and **never anything else** — a failure
+ * to reach anybody comes back as `"rejected"`, because a graph that resumes
+ * with an ambiguous value resumes with whatever the node's `if` happens to do
+ * with it.
+ */
+export class M91InterruptNotifier {
+    client;
+    defaults;
+    constructor(client, defaults = {}) {
+        this.client = client;
+        this.defaults = defaults;
+    }
+    async notify(options) {
+        const { title, customId, ...rest } = options;
+        const merged = { ...this.defaults, ...strip(rest) };
+        try {
+            const approved = await this.client.requestApproval(title, {
+                customId,
+                severity: 'HIGH',
+                timeoutMs: 300_000,
+                ...merged,
+            });
+            return approved ? APPROVED : REJECTED;
+        }
+        catch {
+            // Nobody could be reached, so nobody approved. Resuming a graph with
+            // "approved" because the pager was down is the one outcome worth ruling
+            // out by construction.
+            return REJECTED;
+        }
+    }
+}
+/**
+ * Build a graph node that asks a human and writes the answer into state.
+ *
+ * ```ts
+ * builder.addNode('humanApproval', createM91ApprovalNode(client, {
+ *   approveLabel: 'Deploy Now',
+ *   rejectLabel: 'Hold Release',
+ *   timeoutMs: 600_000,
+ * }));
+ * ```
+ *
+ * The node reads `title` (or `question`) and `customId` from state and returns
+ * `{ decision, approved }` for the next edge to branch on. Anything passed here
+ * is a default the state can override per run.
+ */
+export function createM91ApprovalNode(client, defaults = {}) {
+    const notifier = new M91InterruptNotifier(client, defaults);
+    return async (state) => {
+        const data = (state && typeof state === 'object' ? state : {});
+        const title = data.title ?? data.question;
+        const customId = data.customId ?? data.custom_id;
+        if (!title || !customId) {
+            // Said loudly rather than defaulted. A node that invents a customId is a
+            // node whose alerts never deduplicate and never close.
+            return {
+                decision: REJECTED,
+                approved: false,
+                error: "error: the approval node needs 'title' (or 'question') and 'customId' in state",
+            };
+        }
+        const decision = await notifier.notify({
+            title: String(title),
+            customId: String(customId),
+            ...strip({
+                description: data.description,
+                severity: data.severity,
+                approveLabel: data.approveLabel,
+                rejectLabel: data.rejectLabel,
+                timeoutMs: data.timeoutMs,
+            }),
+        });
+        return { decision, approved: decision === APPROVED };
+    };
+}
+/** Drop undefined keys so a spread cannot blank out a default with `undefined`. */
+function strip(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== undefined));
+}
+//# sourceMappingURL=langgraph.js.map

package/dist/src/integrations/langgraph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"langgraph.js","sourceRoot":"","sources":["../../../src/integrations/langgraph.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAiBhD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,OAAO,oBAAoB;IACd,MAAM,CAAY;IAClB,QAAQ,CAAiB;IAE1C,YAAY,MAAiB,EAAE,WAA2B,EAAE;QAC1D,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,OAAsB;QACjC,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAE,GAAG,OAAO,CAAC;QAC7C,MAAM,MAAM,GAAG,EAAE,GAAG,IAAI,CAAC,QAAQ,EAAE,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;QACpD,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE;gBACxD,QAAQ;gBACR,QAAQ,EAAE,MAAM;gBAChB,SAAS,EAAE,OAAO;gBAClB,GAAG,MAAM;aACV,CAAC,CAAC;YACH,OAAO,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC;QACxC,CAAC;QAAC,MAAM,CAAC;YACP,qEAAqE;YACrE,wEAAwE;YACxE,uBAAuB;YACvB,OAAO,QAAQ,CAAC;QAClB,CAAC;IACH,CAAC;CACF;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,qBAAqB,CACnC,MAAiB,EACjB,WAA2B,EAAE;IAE7B,MAAM,QAAQ,GAAG,IAAI,oBAAoB,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAE5D,OAAO,KAAK,EAAE,KAAc,EAAE,EAAE;QAC9B,MAAM,IAAI,GAAG,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAA4B,CAAC;QAC1F,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,QAAQ,CAAC;QAC1C,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,SAAS,CAAC;QAEjD,IAAI,CAAC,KAAK,IAAI,CAAC,QAAQ,EAAE,CAAC;YACxB,yEAAyE;YACzE,uDAAuD;YACvD,OAAO;gBACL,QAAQ,EAAE,QAAQ;gBAClB,QAAQ,EAAE,KAAK;gBACf,KAAK,EACH,gFAAgF;aACnF,CAAC;QACJ,CAAC;QAED,MAAM,QAAQ,GAAG,MAAM,QAAQ,CAAC,MAAM,CAAC;YACrC,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC;YACpB,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAC;YAC1B,GAAG,KAAK,CAAC;gBACP,WAAW,EAAE,IAAI,CAAC,WAAiC;gBACnD,QAAQ,EAAE,IAAI,CAAC,QAAgC;gBAC/C,YAAY,EAAE,IAAI,CAAC,YAAkC;gBACrD,WAAW,EAAE,IAAI,CAAC,WAAiC;gBACnD,SAAS,EAAE,IAAI,CAAC,SAA+B;aAChD,CAAC;SACH,CAAC,CAAC;QACH,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,KAAK,QAAQ,EAAE,CAAC;IACvD,CAAC,CAAC;AACJ,CAAC;AAED,mFAAmF;AACnF,SAAS,KAAK,CAAoC,KAAQ;IACxD,OAAO,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,SAAS,CAAC,CAAe,CAAC;AACpG,CAAC"}