@noodleseed/one 0.175.1 → 0.176.0

package/node_modules/@noodle-borg/knowledge-operations/dist/service-wiring.js

@@ -32,11 +32,10 @@ export function budgetCeilingsResolver(resolveVariables) {
         };
     };
 }
-/** Assemble route deps over the service's managed-config resolver (`NOODLE_KNOWLEDGE_ENABLED`). */
-export function buildKnowledgeRouteDeps(stores, resolveVariables, maxBodyBytes) {
+/** Assemble the always-available knowledge route dependencies. */
+export function buildKnowledgeRouteDeps(stores, maxBodyBytes) {
     return {
         staging: stores.staging,
-        knowledgeEnabled: async (tenant) => (await resolveVariables(tenant)).NOODLE_KNOWLEDGE_ENABLED === 'true',
         maxBodyBytes,
         ...(stores.codec === undefined ? {} : { codec: stores.codec }),
     };
@@ -61,7 +60,7 @@ export function knowledgeIndexFromDeclaration(declaration, config, scope) {
  */
 export function wireKnowledge(registry, stores, resolveVariables, maxBodyBytes, resolveSecrets = async () => ({})) {
     const resolved = stores ?? defaultKnowledgeStores();
-    const deps = buildKnowledgeRouteDeps(resolved, resolveVariables, maxBodyBytes);
+    const deps = buildKnowledgeRouteDeps(resolved, maxBodyBytes);
     const ceilings = budgetCeilingsResolver(resolveVariables);
     // The managed first-party crawler needs no provisioning, so the deploy gate defaults open;
     // BYO provider configuration checks replace this seam when a component declares a provider.
@@ -117,7 +116,6 @@ export function wireKnowledge(registry, stores, resolveVariables, maxBodyBytes,
         return knowledgeIndexFromDeclaration(resolvedDeclaration, config, scope);
     };
     const hooks = createKnowledgeDeployHooks(resolved, {
-        knowledgeEnabled: deps.knowledgeEnabled,
         siteProvisioned,
         indexFor: resolved.indexFor ?? defaultIndexFor,
     });
@@ -146,12 +144,10 @@ export function wireKnowledge(registry, stores, resolveVariables, maxBodyBytes,
     };
     const bareExecutor = createKnowledgeSearchExecutor({
         hooks,
-        knowledgeEnabled: deps.knowledgeEnabled,
     });
     // Refresh-on-traffic: serving a sites component also checks whether its refresh is due and
     // kicks the crawl in the background — the visitor's answer never waits on it.
     const executor = {
-        enabled: bareExecutor.enabled,
         search: async (tenant, component, request) => {
             const hits = await bareExecutor.search(tenant, component, request);
             if (component.sites.length > 0) {
@@ -182,7 +178,6 @@ export function wireKnowledge(registry, stores, resolveVariables, maxBodyBytes,
     registry.setKnowledgeDeployHooks(crawlingHooks, knowledgeSearchPortFactory(executor));
     const status = {
         revisionStore: resolved.revisionStore,
-        knowledgeEnabled: deps.knowledgeEnabled,
         crawlState: (tenant, componentName) => crawlState.get(tenant, componentName),
         refresh: (tenant, component) => runComponentCrawl(crawlDeps, tenant, component),
         // Mirrors the fail-closed deploy gate above: without the managed project every site() is

package/node_modules/@noodle-borg/knowledge-operations/dist/status-routes.d.ts

@@ -7,10 +7,9 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { CompiledKnowledgeComponent, KnowledgeRevisionStore } from '@noodle-borg/knowledge/portable';
 import type { KnowledgeBudgetState, KnowledgeCrawlState } from '@noodle-borg/wire-contracts';
-import { type KnowledgeTenantRef } from './routes.js';
+import type { KnowledgeTenantRef } from './routes.js';
 export interface KnowledgeStatusDeps {
     readonly revisionStore: KnowledgeRevisionStore;
-    readonly knowledgeEnabled: (tenant: KnowledgeTenantRef) => Promise<boolean>;
     /** The active deployment's compiled knowledge components, or undefined when none is active. */
     readonly activeKnowledge: (tenant: KnowledgeTenantRef) => Promise<{
         readonly components: readonly CompiledKnowledgeComponent[];

package/node_modules/@noodle-borg/knowledge-operations/dist/status-routes.js

@@ -1,12 +1,4 @@
 import { sendJson } from './http.js';
-import { knowledgeEnableCommand } from './routes.js';
-function gateClosed(res, tenant) {
-    sendJson(res, 403, {
-        code: 'knowledge_not_enabled',
-        error: 'knowledge is not enabled for this org/app/env',
-        fix: knowledgeEnableCommand(tenant),
-    });
-}
 async function componentSummary(tenant, component, deploymentId, revisionStore) {
     const scope = { org: tenant.org, app: tenant.app, env: tenant.env };
     const active = component.documents.length > 0 ? await revisionStore.active(scope, component.name) : undefined;
@@ -22,8 +14,6 @@ async function componentSummary(tenant, component, deploymentId, revisionStore)
 }
 /** `GET /v1/orgs/{o}/apps/{a}/envs/{e}/knowledge` */
 export async function handleKnowledgeList(_req, res, tenant, deps) {
-    if (!(await deps.knowledgeEnabled(tenant)))
-        return gateClosed(res, tenant);
     const active = await deps.activeKnowledge(tenant);
     const components = [];
     for (const component of active?.components ?? []) {
@@ -38,8 +28,6 @@ export async function handleKnowledgeList(_req, res, tenant, deps) {
 }
 /** `GET /v1/orgs/{o}/apps/{a}/envs/{e}/knowledge/{name}/status` */
 export async function handleKnowledgeStatus(_req, res, tenant, componentName, deps) {
-    if (!(await deps.knowledgeEnabled(tenant)))
-        return gateClosed(res, tenant);
     const active = await deps.activeKnowledge(tenant);
     const component = active?.components.find((candidate) => candidate.name === componentName);
     if (active === undefined || component === undefined) {
@@ -70,8 +58,6 @@ export async function handleKnowledgeStatus(_req, res, tenant, componentName, de
  * The outcome (including failures) is the returned crawl state, never a thrown error.
  */
 export async function handleKnowledgeRefresh(_req, res, tenant, componentName, deps) {
-    if (!(await deps.knowledgeEnabled(tenant)))
-        return gateClosed(res, tenant);
     const active = await deps.activeKnowledge(tenant);
     const component = active?.components.find((candidate) => candidate.name === componentName);
     if (component === undefined || deps.refresh === undefined) {

package/node_modules/@noodle-borg/protocol/dist/knowledge-tool.js

@@ -2,20 +2,18 @@ import { coerceToolArguments } from './input-validation.js';
 export function findKnowledgeComponent(artifact, toolName) {
     return artifact.server.knowledge?.find((component) => component.generatedTool.name === toolName);
 }
-/** Listing predicate: the artifact declares knowledge AND the deployment's port is live. */
+/** Listing predicate: the artifact declares knowledge and the deployment has a search port. */
 export async function knowledgeToolsEnabled(artifact, deps) {
     if ((artifact.server.knowledge?.length ?? 0) === 0)
         return false;
-    if (deps.knowledgeSearch === undefined)
-        return false;
-    return deps.knowledgeSearch.enabled();
+    return deps.knowledgeSearch !== undefined;
 }
 export async function runKnowledgeSearchTool(component, deps, rawArguments) {
     const coerced = coerceToolArguments(component.generatedTool.inputSchema, rawArguments);
     if (coerced.issues.length > 0)
         return { kind: 'invalid', issues: coerced.issues };
     if (deps.knowledgeSearch === undefined) {
-        return { kind: 'error', reason: 'not_enabled', message: 'knowledge search is unavailable' };
+        return { kind: 'error', reason: 'provider_error', message: 'knowledge search is unavailable' };
     }
     const request = coerced.value;
     const outcome = await deps.knowledgeSearch.search(component.name, request);

package/node_modules/@noodle-borg/runtime/dist/execute.d.ts

@@ -61,10 +61,9 @@ export interface KnowledgeSearchHit {
 }
 /**
  * Deployment-bound knowledge retrieval port (structural; the service adapts its executor).
- * `enabled` gates listing as well as calls — a disabled surface lists no knowledge tools.
+ * Presence of the port makes declared knowledge tools available.
  */
 export interface KnowledgeSearchPort {
-    enabled(): Promise<boolean>;
     search(componentName: string, request: {
         readonly query: string;
         readonly limit?: number | undefined;
@@ -73,7 +72,7 @@ export interface KnowledgeSearchPort {
         readonly hits: readonly KnowledgeSearchHit[];
     } | {
         readonly ok: false;
-        readonly reason: 'budget_exhausted' | 'not_enabled' | 'provider_error';
+        readonly reason: 'budget_exhausted' | 'provider_error';
         readonly message: string;
     }>;
 }

package/node_modules/@noodle-borg/service/dist/assistant-composition.js

@@ -1,3 +1,4 @@
+import { ConversationCapture } from './conversation-history/capture.js';
 /** Browser and messaging resolve model, execution and tenant policy from one composition. */
 export function assistantRouteDependencies(options, core) {
     return {
@@ -13,6 +14,14 @@ export function assistantRouteDependencies(options, core) {
             : {}),
         ...(options.captureRequestEvent ? { captureRequestEvent: options.captureRequestEvent } : {}),
         ...(options.clock ? { clock: options.clock } : {}),
+        ...(options.conversationHistory
+            ? {
+                conversations: new ConversationCapture(options.conversationHistory.store, options.conversationHistory.policy, {
+                    now: () => (options.clock?.() ?? new Date()).getTime(),
+                    ...(core.logger ? { logger: core.logger } : {}),
+                }),
+            }
+            : {}),
     };
 }
 //# sourceMappingURL=assistant-composition.js.map

package/node_modules/@noodle-borg/service/dist/business-information/validation.js

@@ -1,3 +1,4 @@
+import { looksLikePaymentCard } from '../payment-card.js';
 import { MANAGED_RETENTION_DAYS } from './contracts.js';
 export const MAX_PAYLOAD_BYTES = 32 * 1024;
 export const MAX_PAYLOAD_DEPTH = 6;
@@ -113,28 +114,6 @@ function validateString(value, path) {
         throw new PayloadValidationError('health_biometric_value', `${path} contains health or biometric data`);
     }
 }
-function looksLikePaymentCard(value) {
-    const candidates = value.match(/(?:\d[ -]?){13,19}/g) ?? [];
-    return candidates.some((candidate) => {
-        const digits = candidate.replace(/\D/g, '');
-        return digits.length >= 13 && digits.length <= 19 && luhnValid(digits);
-    });
-}
-function luhnValid(digits) {
-    let sum = 0;
-    let double = false;
-    for (let index = digits.length - 1; index >= 0; index -= 1) {
-        let digit = Number(digits[index]);
-        if (double) {
-            digit *= 2;
-            if (digit > 9)
-                digit -= 9;
-        }
-        sum += digit;
-        double = !double;
-    }
-    return sum % 10 === 0;
-}
 function isPlainObject(value) {
     if (typeof value !== 'object' || value === null || Array.isArray(value))
         return false;

package/node_modules/@noodle-borg/service/dist/channels/360dialog.js

@@ -2,6 +2,7 @@ import { timingSafeEqual } from 'node:crypto';
 import { ChannelError, } from '@noodle-borg/assistant-gateway/portable';
 import { guardedFetch } from '@noodle-borg/connector-http';
 import { z } from 'zod';
+import { boundedJson, cloudApiHealth, cloudApiSend, cloudApiSetBlocked, } from './provider.js';
 export const WHATSAPP_CALLBACK_HEADER = 'x-noodle-webhook-secret';
 const identifier = z.string().min(1).max(512);
 const timestamp = z
@@ -17,6 +18,10 @@ const valueSchema = z.object({
         id: identifier,
         from: z.string().max(128).optional(),
         user_id: z.string().max(128).optional(),
+        // Meta's business-scoped user id field for senders who adopted usernames (Meta BSUID guide,
+        // https://developers.facebook.com/documentation/business-messaging/whatsapp/business-scoped-user-ids/,
+        // read 2026-09-22); `from` still wins whenever the phone number is present.
+        from_user_id: z.string().max(128).optional(),
         timestamp,
         type: z.string().max(64),
         text: z.object({ body: z.string().max(1 << 20) }).optional(),
@@ -79,10 +84,11 @@ export function parseWhatsAppWebhook(input, phoneNumberId) {
                 throw new ChannelError('asset_mismatch');
             for (const message of value.messages ?? []) {
                 let address;
+                const opaque = message.user_id ?? message.from_user_id;
                 if (message.from && /^[1-9]\d{5,14}$/.test(message.from))
                     address = { kind: 'phone', value: message.from };
-                else if (message.user_id && /^[A-Z]{2}\.[A-Za-z0-9]{1,124}$/.test(message.user_id))
-                    address = { kind: 'opaque', value: message.user_id };
+                else if (opaque && /^[A-Z]{2}\.[A-Za-z0-9]{1,124}$/.test(opaque))
+                    address = { kind: 'opaque', value: opaque };
                 else
                     throw new ChannelError('recipient_invalid');
                 const button = message.type === 'interactive' && message.interactive?.type === 'button_reply'
@@ -103,32 +109,6 @@ export function parseWhatsAppWebhook(input, phoneNumberId) {
         }
     return { messages, statuses };
 }
-/** A 4xx that judges the payload itself; auth, throttling and timeouts are no reason to resend differently. */
-function rejectedPayload(status) {
-    return status >= 400 && status < 500 && ![401, 403, 408, 429].includes(status);
-}
-async function boundedJson(response) {
-    const reader = response.body?.getReader();
-    if (!reader)
-        throw new ChannelError('provider_response_invalid');
-    const chunks = [];
-    let size = 0;
-    try {
-        for (;;) {
-            const result = await reader.read();
-            if (result.done)
-                break;
-            size += result.value.byteLength;
-            if (size > 65_536)
-                throw new ChannelError('provider_response_invalid');
-            chunks.push(result.value);
-        }
-        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
-    }
-    finally {
-        await reader.cancel().catch(() => undefined);
-    }
-}
 export class Dialog360 {
     apiKey;
     fetcher;
@@ -146,23 +126,7 @@ export class Dialog360 {
         });
     }
     async health() {
-        const response = await this.request('/health_status?fields=id');
-        if (!response.ok)
-            throw new ChannelError('provider_unavailable');
-        const parsed = z
-            .object({
-            id: identifier,
-            health_status: z.object({ can_send_message: z.enum(['AVAILABLE', 'LIMITED', 'BLOCKED']) }),
-        })
-            .safeParse(await boundedJson(response));
-        if (!parsed.success)
-            throw new ChannelError('provider_response_invalid');
-        return {
-            phoneNumberId: parsed.data.id,
-            // LIMITED meets provider messaging requirements; provider limits still govern each send.
-            canSend: parsed.data.health_status.can_send_message !== 'BLOCKED',
-            status: parsed.data.health_status.can_send_message,
-        };
+        return cloudApiHealth(await this.request('/health_status?fields=id'));
     }
     async webhook() {
         const response = await this.request('/v1/configs/webhook');
@@ -194,107 +158,39 @@ export class Dialog360 {
             throw new ChannelError('webhook_configuration_failed');
         await response.body?.cancel();
     }
-    async setBlocked(phone, blocked) {
-        try {
-            const response = await this.request('/block_users', blocked ? 'POST' : 'DELETE', {
-                messaging_product: 'whatsapp',
-                block_users: [{ user: phone }],
-            });
-            if (!response.ok) {
-                await response.body?.cancel();
-                return {
-                    state: response.status >= 500 ? 'unknown' : 'error',
-                    code: `provider_http_${response.status}`,
-                };
-            }
-            const field = blocked ? 'added_users' : 'removed_users';
-            const parsed = z
-                .object({
-                block_users: z.object({
-                    [field]: z.array(z.object({ input: z.string(), wa_id: z.string() })),
-                }),
-            })
-                .safeParse(await boundedJson(response));
-            return parsed.success &&
-                parsed.data.block_users[field]?.some((user) => user.input === phone || user.wa_id === phone)
-                ? { state: 'confirmed' }
-                : { state: 'unknown', code: 'provider_receipt_invalid' };
-        }
-        catch {
-            return { state: 'unknown', code: 'provider_outcome_unknown' };
-        }
+    setBlocked(phone, blocked) {
+        return cloudApiSetBlocked((...args) => this.request(...args), phone, blocked);
     }
-    /**
-     * One reply. With buttons the review goes as an interactive reply-button message: at most three
-     * buttons, titles up to 20 characters, ids up to 256 and a body up to 1024 characters, per the
-     * Meta Cloud API reply-buttons reference that the 360dialog Cloud API host relays (360dialog's own
-     * interactive-messages page states only the three-button limit; its webhook reference gives the
-     * inbound shape); all checked 2026-09-21. A payload the provider rejects outright dispatched
-     * nothing, so the same text goes plain instead; an ambiguous outcome is never retried.
-     */
-    async send(input) {
-        if (!input.text || input.text.length > 4096)
-            return { state: 'failed', code: 'reply_invalid' };
-        const buttons = input.buttons ?? [];
-        const interactive = buttons.length > 0 &&
-            buttons.length <= 3 &&
-            input.text.length <= 1024 &&
-            buttons.every((button) => button.id.length <= 256 && button.title.length <= 20);
-        const envelope = {
-            messaging_product: 'whatsapp',
-            recipient_type: 'individual',
-            ...(input.to.kind === 'phone' ? { to: input.to.value } : { recipient: input.to.value }),
-        };
-        try {
-            let code;
-            let response = interactive
-                ? await this.request('/messages', 'POST', {
-                    ...envelope,
-                    type: 'interactive',
-                    interactive: {
-                        type: 'button',
-                        body: { text: input.text },
-                        action: {
-                            buttons: buttons.map((button) => ({
-                                type: 'reply',
-                                reply: { id: button.id, title: button.title },
-                            })),
-                        },
-                    },
-                })
-                : undefined;
-            if (response !== undefined && !response.ok && rejectedPayload(response.status)) {
-                await response.body?.cancel();
-                code = 'interactive_rejected';
-                response = undefined;
-            }
-            if (response === undefined)
-                response = await this.request('/messages', 'POST', {
-                    ...envelope,
-                    type: 'text',
-                    text: { body: input.text, preview_url: false },
-                });
-            if (!response.ok) {
-                await response.body?.cancel();
-                return {
-                    state: response.status >= 500 || response.status === 408 ? 'unknown' : 'failed',
-                    code: `provider_http_${response.status}`,
-                };
-            }
-            const parsed = z
-                .object({ messages: z.array(z.object({ id: identifier })).length(1) })
-                .safeParse(await boundedJson(response));
-            return parsed.success
-                ? {
-                    state: 'accepted',
-                    providerMessageId: parsed.data.messages[0].id,
-                    ...(code === undefined ? {} : { code }),
-                }
-                : { state: 'unknown', code: 'provider_receipt_invalid' };
-        }
-        catch {
-            return { state: 'unknown', code: 'send_outcome_unknown' };
-        }
+    /** One reply; request bodies and fallback semantics are shared in `cloudApiSend`. */
+    send(input) {
+        return cloudApiSend((...args) => this.request(...args), input);
     }
 }
+/**
+ * One 360dialog binding as a provider: its channel key's adapter plus its per-binding callback secret.
+ * The callback carries the secret as a header; an existing callback owned by another URL is never
+ * taken over.
+ */
+export function dialog360Provider(adapter, webhookSecret) {
+    return {
+        health: () => adapter.health(),
+        setBlocked: (phone, blocked) => adapter.setBlocked(phone, blocked),
+        send: (input) => adapter.send(input),
+        async inspectWebhook(url) {
+            const current = await adapter.webhook();
+            return {
+                matches: current.url === url,
+                authenticated: verifyWhatsAppWebhookSecret(current.headers?.[WHATSAPP_CALLBACK_HEADER], webhookSecret),
+            };
+        },
+        async configureWebhook(url) {
+            const existing = await adapter.webhook();
+            if (existing.url && existing.url !== url)
+                throw new ChannelError('webhook_ownership_conflict');
+            if (existing.url !== url ||
+                !verifyWhatsAppWebhookSecret(existing.headers?.[WHATSAPP_CALLBACK_HEADER], webhookSecret))
+                await adapter.configureWebhook(url, webhookSecret);
+        },
+    };
+}
 //# sourceMappingURL=360dialog.js.map

package/node_modules/@noodle-borg/service/dist/channels/composition.js

@@ -11,6 +11,7 @@ export async function createPostgresWhatsApp(pool, secretBox, options) {
     return {
         store,
         worker: new ChannelWorkerLoop((code) => (options.logger ?? noopLogger).warn('assistant.channel.worker', { code })),
+        ...(options.whatsappMeta ? { meta: options.whatsappMeta } : {}),
     };
 }
 export function createWhatsAppRuntime(options, deps, history) {

package/node_modules/@noodle-borg/service/dist/channels/meta-cloud.js

@@ -0,0 +1,102 @@
+import { ChannelError } from '@noodle-borg/assistant-gateway/portable';
+import { guardedFetch } from '@noodle-borg/connector-http';
+import { z } from 'zod';
+import { boundedJson, cloudApiHealth, cloudApiSend, cloudApiSetBlocked, } from './provider.js';
+/**
+ * Graph API version for every Meta call. Graph API changelog (read 2026-09-22,
+ * https://developers.facebook.com/docs/graph-api/changelog): v25.0 released 2026-02-18 and available
+ * until 2028-07-29; v26.0 (2026-07-29) is newer, but Meta's WhatsApp references and Noodle Seed's
+ * App Dashboard examples use v25.0. Operators may pin another with NOODLE_WHATSAPP_META_GRAPH_VERSION.
+ */
+export const WHATSAPP_META_GRAPH_VERSION = 'v25.0';
+/** The one callback every Meta-connected number shares; bindings are found by phone-number id. */
+export const WHATSAPP_META_CALLBACK_PATH = '/v1/channels/whatsapp/meta';
+const node = /^\d{1,32}$/;
+const subscriptions = z.object({
+    data: z
+        .array(z.object({ whatsapp_business_api_data: z.object({ id: z.string().max(64) }) }))
+        .max(100),
+});
+/**
+ * One Meta-connected number, called directly on graph.facebook.com with the business's token.
+ * Sources, all read 2026-09-22 and using v25.0 in their examples:
+ * - send: POST /{phone_number_id}/messages, Bearer token, `messages[].id` receipt
+ *   (https://developers.facebook.com/docs/whatsapp/cloud-api/reference/messages); a business-scoped
+ *   user id goes in `recipient` instead of `to`
+ *   (https://developers.facebook.com/documentation/business-messaging/whatsapp/business-scoped-user-ids/).
+ * - health: GET /{node}?fields=health_status returns `id` and `health_status.can_send_message`
+ *   AVAILABLE | LIMITED | BLOCKED (https://developers.facebook.com/docs/whatsapp/cloud-api/health-status).
+ * - block: POST | DELETE /{phone_number_id}/block_users, receipts in `block_users.added_users` /
+ *   `removed_users` (https://developers.facebook.com/docs/whatsapp/cloud-api/block-users).
+ * - webhooks: GET | POST /{waba_id}/subscribed_apps; the GET lists
+ *   `data[].whatsapp_business_api_data.id`, the POST answers `{"success": true}`
+ *   (https://developers.facebook.com/docs/whatsapp/embedded-signup/webhooks).
+ */
+export class MetaCloud {
+    token;
+    asset;
+    app;
+    fetcher;
+    phone;
+    constructor(token, asset, app, fetcher = (url, init) => guardedFetch(new URL(url), init)) {
+        this.token = token;
+        this.asset = asset;
+        this.app = app;
+        this.fetcher = fetcher;
+        if (!/^v\d{1,3}\.\d{1,2}$/.test(app.graphVersion) || !node.test(app.appId))
+            throw new ChannelError('provider_configuration_invalid');
+        this.phone = (path, method, body) => this.request(asset.phoneNumberId, path, method, body);
+    }
+    async request(id, path, method = 'GET', body) {
+        if (!node.test(id))
+            throw new ChannelError('provider_asset_invalid');
+        return this.fetcher(`https://graph.facebook.com/${this.app.graphVersion}/${id}${path}`, {
+            method,
+            headers: { authorization: `Bearer ${this.token}`, 'content-type': 'application/json' },
+            ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+            redirect: 'manual',
+            signal: AbortSignal.timeout(15_000),
+        });
+    }
+    async health() {
+        return cloudApiHealth(await this.phone('?fields=id,health_status'));
+    }
+    setBlocked(phone, blocked) {
+        return cloudApiSetBlocked(this.phone, phone, blocked);
+    }
+    send(input) {
+        return cloudApiSend(this.phone, input);
+    }
+    async subscribed() {
+        const response = await this.request(this.asset.wabaId, '/subscribed_apps');
+        if (!response.ok) {
+            await response.body?.cancel();
+            throw new ChannelError('provider_unavailable');
+        }
+        const parsed = subscriptions.safeParse(await boundedJson(response));
+        if (!parsed.success)
+            throw new ChannelError('provider_response_invalid');
+        return parsed.data.data.some((app) => app.whatsapp_business_api_data.id === this.app.appId);
+    }
+    /**
+     * `matches` means the WABA delivers to this Meta app; `authenticated` means the platform holds the
+     * app secret that signs callbacks, which constructing this adapter requires. The app-level
+     * callback URL is set once in the Meta App Dashboard and is not read here.
+     */
+    async inspectWebhook(_url) {
+        return { matches: await this.subscribed(), authenticated: true };
+    }
+    async configureWebhook(_url) {
+        if (await this.subscribed())
+            return;
+        const response = await this.request(this.asset.wabaId, '/subscribed_apps', 'POST');
+        const parsed = response.ok
+            ? z.object({ success: z.literal(true) }).safeParse(await boundedJson(response))
+            : undefined;
+        if (!response.ok)
+            await response.body?.cancel();
+        if (!parsed?.success)
+            throw new ChannelError('webhook_configuration_failed');
+    }
+}
+//# sourceMappingURL=meta-cloud.js.map