@open-everywhere/provider-teams 0.0.0-stage → 0.1.0

package/dist/agent/channels/teams-supervisor.d.ts

@@ -0,0 +1,351 @@
+import { type VendorEventTime, type NormalizedWake, type WakeEngagementTier, type WakeTrust, type UnifiedWindowWake, type WakeMessageInput, type IngestedChatMessage, type SessionTailWakeRow, type SeatCatchUpRequest, type SeatCatchUpResult } from "@open-everywhere/core/agent/adapter-api.js";
+import type { OpenEverywhereTeamsAuth } from "./teams-identity.js";
+/** The per-container supervisor token for a Teams channel container (the grain fallback —
+ *  see the header note; a live Teams dispatch always resolves the unified domain token). */
+export declare function teamsSupervisorToken(channelKey: string, generation: number): string;
+/** The host-extracted Teams facts the floor decides from — every field comes off the
+ *  JWT-VERIFIED inbound activity (or the operator's own registers), never model output. */
+export interface TeamsSingleWindowFacts {
+    /** Normalized conversation scope ("personal" | "groupChat" | "channel" | "unknown"). */
+    readonly scope: string | undefined;
+    /** Channel membershipType ("standard" | "private" | "shared") when the activity's channelData
+     *  positively carried it — inbound activities usually OMIT it (teams-identity.ts). */
+    readonly membershipType?: string;
+    /** The tenant (org boundary). Absent ⇒ the surface can't be anchored to an org ⇒ refuse. */
+    readonly tenantId?: string;
+    /** The operator's explicit vouch for THIS surface: isVouchedSurface on the channel key AND the
+     *  team rung, which WALKS the declaration rungs (OPE-1521/OPE-1538), so a tenant-grain
+     *  `teams/<tenant>` declaration vouches every room under it and a `public` `team:<id>` carve-out
+     *  demotes one team out of it — see below. Or the blanket OE_TRUST=internal. Resolved by the
+     *  live wiring (teams-front.ts). */
+    readonly vouched: boolean;
+}
+/**
+ * The Teams privacy floor for the cross-surface window, FAIL-CLOSED. Every surface has one so a
+ * public/external surface can never join a private shared window (GitHub: `repository.private
+ * === true`; Slack: positively-confirmed-internal channel/group; Linear: team positively
+ * private; Notion: operator vouch). Teams' rule:
+ *
+ *   ADMIT ⟺ scope === "channel"  AND  tenantId present  AND  membershipType ≠ "shared"
+ *          AND  the OPERATOR VOUCHED the surface (vouch register / OE_TRUST=internal).
+ *
+ * WHY OPERATOR-VOUCH AND NOT A PLATFORM SIGNAL (the Notion posture, deliberately): Teams has NO
+ * reliable in-band fact that means "internal-only, no external eyes".
+ *   • `membershipType` is usually ABSENT on inbound activities, and even when positively
+ *     "standard" or "private" it does NOT exclude tenant GUESTS — a guest (an external identity
+ *     invited into the tenant) sees every standard channel of the teams they're on, and can be a
+ *     member of private channels too. So the memory-gate verdict (teams-identity.ts teamsTrust,
+ *     which reads standard/private+tenant as internal) is deliberately NOT sufficient here —
+ *     the window floor is STRICTER than the memory floor.
+ *   • A Graph roster sweep (TeamMember.Read.All → userType === "Guest") could positively prove
+ *     guest-freedom, but OE has no Graph credential plane wired (the bot speaks Bot Connector
+ *     only), the sweep is racy (membership changes after the check), and Bot-Framework
+ *     pagedMembers' `userRole` is not a documented-reliable field — inventing a weaker signal
+ *     is exactly what the floor doctrine forbids. So: the operator vouches, code enforces.
+ *
+ * ATTACKER ANALYSIS: the leak vector is a message from a surface visible outside the org being
+ * admitted to (and answered from) a private cross-surface window. All four conjuncts are
+ * host-derived: scope/membershipType/tenantId come off the Bot-Connector-signed activity (a
+ * user cannot author channelData — the Teams service stamps it), and the vouch is the
+ * operator's own register. Absence of membershipType never ADMITS (only the vouch admits;
+ * membershipType only REFUSES). The one positive-external fact we CAN see — membershipType ===
+ * "shared", a Teams Connect shared channel spanning tenants — refuses EVEN WHEN VOUCHED (a
+ * positive cross-org fact beats a standing assertion). BUT membershipType is usually ABSENT
+ * inbound, and an absent signal never demotes, so that guard catches only the rooms Teams labels
+ * for us.
+ *
+ * 🔴 THERE IS NO EXACT-GRAIN BACKSTOP BEHIND IT — the operator's declaration IS the protection.
+ * `isVouchedSurface` walks the declaration rungs (OPE-1521), the same most-specific-wins walk every
+ * other trust reader uses, and since OPE-1538 the wiring hands it the TEAM rung too, so the walk
+ * here has the same reach the binding and memory planes have: a `public` `teams/<tenant>/team:<id>`
+ * carve-out now demotes one team out of an internal tenant at this floor, where it used to be
+ * skipped and the room admitted. A coarse `teams/<tenant>` declaration still admits EVERY room under
+ * that tenant that no narrower entry demotes. `agent/identity/surfaces.ts` ships exactly such a tenant line today. A native
+ * internal channel and a cross-tenant Connect/shared channel look alike at that grain, so a
+ * shared room whose inbound activities omit membershipType IS admitted on the tenant line. That is
+ * the ruling, not a gap: a declaration vouches, and only a POSITIVE external signal demotes. The
+ * operator narrows the reach by declaring the channel rung instead. This floor admits or refuses a
+ * room that is ALREADY a window member — it enrolls nobody; the domain CONFIG
+ * (`agent/memory/config/domains.ts`, read by teams-front.ts) enrolls. Do not read that as a second
+ * bound on the reach: a domain's container `reach` entry is legal at TENANT grain, so a tenant claim
+ * beside a tenant declaration puts every room in the tenant through this floor, and config load
+ * cannot enumerate them. In-tree domains name exact channels today. Residual: the standing
+ * "operator vouched something they shouldn't have" residual every vouch surface carries (identical
+ * to vouching a web-published Notion page) — now at whatever grain the operator wrote, so a tenant
+ * declaration carries it for the whole tenant. Personal and group chats
+ * are refused outright: they are per-person surfaces, not org containers, mirroring Slack's
+ * channels/groups-only rule. Residual acceptance: a vouched tenant/channel that LATER gains a
+ * guest is admitted until the operator retracts the vouch — the documented trade of the vouch
+ * posture (identical to Notion's), and strictly safer than any inference we could make.
+ */
+export declare function teamsSingleWindowPrivacyOk(f: TeamsSingleWindowFacts): boolean;
+/** The host-frozen reply-target facts one Teams activity resolves — everything
+ *  {@link planTeamsSingleWindow} needs to mint the wake origin (unified-window.ts's teams arm). */
+export interface TeamsSingleWindowTarget {
+    /** Bot Connector base URL off the verified activity — the reply's transport host. Empty ⇒ no
+     *  routable reply target ⇒ NO window (fail closed, never an unanswerable wake). */
+    readonly serviceUrl: string;
+    /** The Bot Framework conversation id (channel messages carry the reply-chain anchor in it). */
+    readonly conversationId: string;
+    /** The reply-chain ROOT activity id (eve's teamsThreadRootActivityId: the trigger's replyToId
+     *  when it was itself a reply, else the trigger activity) — replyToTeamsActivity's target. */
+    readonly replyToActivityId?: string;
+    readonly tenantId?: string;
+    /** The first latency anchor (OPE-1716), recorded on the ingress row. A Bot-Framework activity
+     *  carries no parsed timestamp on eve's shape, so the caller passes its own FRONT-DOOR RECEIPT —
+     *  which makes the vendor→ingress segment a lower bound, and the row's `vendorTsSource` says so. */
+    readonly vendorTs?: VendorEventTime;
+}
+/**
+ * The ONE single-window decision for a Teams delivery, mirroring planNotionSingleWindow: given
+ * the grain's `singleWindow`, whether the activity @mentions the bot, the PRIVACY-FLOOR facts,
+ * and the frozen reply target, return the {@link UnifiedWindowWake} the dispatch should carry —
+ * or undefined for the byte-identical native path (teams-front then FORWARDS the activity to
+ * eve's native teamsChannel exactly as today).
+ *
+ * Teams' mention signal lives in ONE Bot-Framework activity (no Slack-style dual event), and its
+ * "native" handler is the forward this plan suppresses — so suppress-native and divert are the
+ * SAME act, both read off this one verdict (never a double turn, never a gap):
+ *   • @mention on a singleWindow, floor-passing channel → the seam suppresses the native forward
+ *     and stamps `addressing:"direct-mention"` (the terminal-prose delivery bridge's arm);
+ *   • ambient (non-mention) channel message on the same surface → Leg A: the window WITHOUT the
+ *     addressed stamp (judged treatment in the shared window, prose stays hard-dropped);
+ *   • floor fails, singleWindow off, or no routable reply target → undefined (forward — a
+ *     mention then keeps today's native conversation-session turn).
+ */
+export declare function planTeamsSingleWindow(singleWindow: boolean, isMention: boolean, facts: TeamsSingleWindowFacts, target: TeamsSingleWindowTarget): UnifiedWindowWake | undefined;
+export interface TeamsSupervisorWakeInput {
+    /** The Teams CHANNEL id (the container — the envelope's `<channel id>`; the conversation id
+     *  when the activity carried no channel id). */
+    readonly channelId: string;
+    /** The trigger activity's facts (host-extracted). */
+    readonly trigger: {
+        readonly id: string;
+        readonly authorId: string;
+        readonly authorName?: string;
+        readonly sentAt: string;
+        readonly text: string;
+        /** Per-message trust tier (identity/wake-trust.ts) — resolved by the live dispatch.
+         *  🔴 REQUIRED (OPE-596): this builder fail-closed to `relay` while its five siblings defaulted
+         *  UPWARD, so all six now refuse the omission at compile time instead of each picking a floor.
+         *  A caller that cannot resolve a tier states the fail-closed one itself: `relay` for a machine
+         *  author, `unauth` for a human the gate cannot vouch. */
+        readonly trust: WakeTrust;
+    };
+    /** Present ⇔ the trigger sat inside an EXISTING reply chain (its replyToId) — envelope thread
+     *  meta only; the reply target is the frozen origin, never this. */
+    readonly threadRootId?: string;
+    /** The seam's addressed verdict (window.addressing === "direct-mention"). */
+    readonly directMention: boolean;
+    /** Host-minted wake id — always present (Teams only dispatches on the single-window path). */
+    readonly wakeId: string;
+    /** Engagement calibration for the judged preamble — channel-watch only. */
+    readonly engagementTier?: WakeEngagementTier;
+    /** The OUTGOING generation's recorded TAIL (OPE-794), rendered as this first wake's backscroll.
+     *  Only a FRESH generation's first wake carries one. */
+    readonly tail?: readonly WakeMessageInput[];
+    /** This surface could not read its own channel since the seat's last wake (core
+     *  channels/seat-catch-up.ts). Rendered as a trusted `<system-note>`; unset ⇒ no note. */
+    readonly catchUpUnavailable?: string;
+}
+/**
+ * Build the NormalizedWake for one Teams single-window turn. platform "teams", containerNoun
+ * "channel" (a Teams channel is a channel), locus.channel = the Teams channel, locus.thread =
+ * the reply chain the trigger sat in (when it did). NO PLATFORM-FETCH BOOTSTRAP: the Bot Connector
+ * API this wake arrives over has no message-history read (unlike Slack's conversations.history), so a
+ * FRESH generation carries the RECORDED TAIL of the outgoing generation (OPE-794) and nothing else —
+ * which is why the recorded ring matters more on Teams than anywhere else. A Teams seat with no
+ * recorded tail opens cold, honestly.
+ * 🔴 AN ONGOING GENERATION IS A DIFFERENT QUESTION, AND IT IS ANSWERED (OPE-1726): the since-last-wake
+ * catch-up reads MICROSOFT GRAPH — a different credential and a different transport from the Bot
+ * Connector, the one `read_channel` has always used — so a Teams seat does see what the channel said
+ * between its own wakes. See channels/teams-catch-up.ts; the bootstrap gap above is unchanged.
+ * Always the unified render (platform address + P5 disclosure): Teams has no non-window
+ * supervisor path, so there is no per-container twin to stay byte-identical with.
+ */
+export declare function buildTeamsSupervisorWake(input: TeamsSupervisorWakeInput): NormalizedWake;
+/** The live supervisor session pointer, as the deps report it (mirrors the other surfaces). */
+export interface TeamsSupervisorSession {
+    readonly token: string;
+    readonly generation: number;
+    readonly freshGeneration: boolean;
+    /** ISO-8601 of the most recent wake this generation delivered (the registry row's `lastWakeAt`),
+     *  or null on a freshly minted/rotated generation — the lower bound of the since-last-wake catch-up
+     *  read (OPE-1726); absent ⇒ no catch-up. */
+    readonly lastWakeAt?: string | null;
+    /** The OUTGOING generation's recorded tail, oldest-first — empty unless this is a fresh
+     *  generation's first wake (OPE-794). */
+    readonly tail: readonly WakeMessageInput[];
+}
+/** Deps for {@link handleTeamsSingleWindowDispatch} — injected so the core is unit-testable over
+ *  a mock store + a capture `wake` (scripts/unified-window-test.ts). org is baked into the live
+ *  impl's closures (a deployment fact — teams-front.ts), so it never crosses this boundary. */
+export interface TeamsSupervisorDeps {
+    /** Create-or-fetch the live supervisor session for this surface's grain: generation 1 on first
+     *  sighting, rotate when shouldRotate says it aged out, else the current generation. */
+    readonly getOrCreateSession: (surfaceKey: string, channelId: string, atIso: string) => Promise<TeamsSupervisorSession>;
+    /** Record one wake on the current generation (lastWakeAt/turnCount). Best-effort. */
+    readonly touchSession?: (surfaceKey: string, atIso: string) => Promise<void>;
+    /**
+     * THE SINCE-LAST-WAKE CATCH-UP, through the ONE shared path every surface takes
+     * (channels/seat-catch-up.ts `seatCatchUp`). Optional so older test doubles keep compiling
+     * (absent ⇒ no catch-up, the pre-OPE-1726 behaviour); fail-soft by construction.
+     */
+    readonly catchUp?: (req: SeatCatchUpRequest) => Promise<SeatCatchUpResult>;
+    /**
+     * Record this delivered wake onto the LIVE generation's TAIL ring (OPE-794). Injected because the
+     * entry has to be filed under an ORG and a registry key, and this core deliberately holds neither
+     * — the live wiring does. Absent (a unit test) ⇒ nothing is recorded and the dispatch is
+     * unchanged, which is the same posture `touchSession` takes.
+     */
+    readonly recordWake?: (entry: SessionTailWakeRow, token: string, surfaceKey: string) => Promise<void>;
+    /** Deliver the rendered wake. The live wiring (teams-front.ts) ALWAYS diverts through eve's
+     *  cross-channel `receive` into the synthetic `unified` channel (divertToUnifiedWindow) — a
+     *  Teams dispatch has no native send fallback, by construction (window required below). */
+    readonly wake: (input: {
+        token: string;
+        auth: OpenEverywhereTeamsAuth;
+        message: string;
+        context: readonly string[];
+        window: UnifiedWindowWake;
+    }) => Promise<void>;
+    /** Clock seam (defaults to the real clock). */
+    readonly now?: () => string;
+}
+/** Everything teams-front hands the dispatch: identity/session facts + the wake parts + the
+ *  REQUIRED window (a Teams dispatch exists only on the single-window path). */
+export interface TeamsSupervisorDispatch {
+    /** The DOMAIN-GRAIN surface key (`teams/<tenant>/<channel>` — memory/partition.ts domainKeyOf):
+     *  the gate/registry/audit key, and what unified.receive re-checks fail-closed. */
+    readonly surfaceKey: string;
+    /**
+     * 🔴 THE ROOM KEY — `partition.surfaceKey`, the CONVERSATION grain (`teams/<tenant>/<conversation
+     * id>`), and NOT {@link surfaceKey} above. It is the `container` this wake row carries, and it is
+     * a CONTRACT with the post row: `channels/session-tail-record.ts` `tailWindowFor` builds a post's
+     * container from `partition.surfaceKey`, and `channels/reply-fold.ts` filters the ring by exact
+     * container equality. Two spellings therefore hide every wake row from the fold policy.
+     *
+     * WHY THE TWO KEYS DIFFER HERE. `bindTeams` (teams-identity.ts) sets `surface` to the conversation
+     * id (one reply chain) and `domainSurface` to the channel id, so `surfaceKey` and `domainKeyOf` are
+     * different strings on Teams. 🔴 TEAMS IS NOT THE ONLY SURFACE THAT SPLITS THEM. `bindDiscord`
+     * (discord-identity.ts) sets `domainSurface` to the parent channel id, so a Discord THREAD splits
+     * the same two grains. Those two are the whole set — `memory/partition.ts` names both, and no other
+     * binding sets `domainSurface`. Slack sets none, so its two keys are one string and
+     * `slack-events.ts` reads `p.surfaceKey` with nothing to get wrong. Discord
+     * passes `input.partition.surfaceKey` explicitly and is correct today; a future change to that ring
+     * row must keep the surface key, for the reason this field exists. Recording the domain key here
+     * made the fold policy refuse a post that a human message had already cleared (OPE-1528, ship #174).
+     */
+    readonly containerKey: string;
+    /** The Teams channel id (envelope container + the per-container token fallback). */
+    readonly channelId: string;
+    /** The TEAM the channel belongs to, in GRAPH's spelling — the Microsoft 365 GROUP id, NOT the
+     *  `channelData.team.id` an activity carries (channels/teams-graph-team-id.ts resolves the one
+     *  into the other; OPE-1808). Graph addresses a channel read as `/teams/{team}/channels/{channel}`,
+     *  so the catch-up needs both ids and neither is derivable from the other. Absent (a chat activity,
+     *  or a team id that would not resolve) ⇒ no catch-up, never a guessed team. */
+    readonly teamId?: string;
+    /** The activity DID name a team and its Graph id would not resolve ON THIS WAKE — the TRANSIENT
+     *  shape, kept apart from the chat shape because the two owe the seat DIFFERENT sentences (the
+     *  catch-up arm below). Absent ⇒ the activity named no team at all. */
+    readonly teamAddressUnresolved?: boolean;
+    readonly auth: OpenEverywhereTeamsAuth;
+    /**
+     * THE AUTHOR FACTS for every message whose bytes enter this wake's context (OPE-1747), in the same
+     * shape and for the same reason the other three seat surfaces carry it. A Teams channel activity is
+     * one message per wake, so the front passes exactly one entry — the resolved tier, the Bot Connector
+     * roster's `userRole: "guest"` refutation, and the OPERATOR's register query.
+     *
+     * 🔴 REQUIRED, NOT OPTIONAL, for the reason `stampNonMemberChatAuth` makes its own `room` argument
+     * required: an optional field lets a new leg silently lose the author question, and a carriage that is
+     * absent looks identical to a carriage that answered "member". The front already computed these facts
+     * for its own taint join; what this field adds is that the TAIL ROW records them, so a tail-built
+     * envelope is judged by the same two legs a freshly-fetched one is. A leg with genuinely nothing to
+     * say passes `[]` and says so on purpose.
+     */
+    readonly ingested: readonly IngestedChatMessage[];
+    readonly trigger: TeamsSupervisorWakeInput["trigger"];
+    readonly threadRootId?: string;
+    /**
+     * 🔴 THE REPLY CHAIN THIS WAKE SITS IN — the second half of the catch-up's read, and NOT {@link
+     * threadRootId} (OPE-1817). A Teams CHANNEL activity always sits in one reply chain, named by its
+     * conversation id's `;messageid=<root>` suffix, and {@link containerKey} is that same conversation
+     * grain. `threadRootId` answers a different question — whether the ENVELOPE renders thread-scoped
+     * — and is deliberately absent on a top-level post.
+     *
+     * Naming the chain matters because Graph's `/channels/{c}/messages` returns TOP-LEVEL messages
+     * ONLY: a reply never appears there. So a wake that named no chain read nothing for a chain that
+     * had carried the message, with no error to see (ship #206, ship #207). The fetch reads the
+     * channel AND the named chain and merges them (channels/teams-catch-up.ts). Absent ⇒ the
+     * conversation names no chain, and the read is the container's alone.
+     */
+    readonly replyChainRootId?: string;
+    readonly engagementTier?: WakeEngagementTier;
+    /** The minted single-window wake (planTeamsSingleWindow) — REQUIRED: without a window there is
+     *  nothing for this dispatch to do (the front forwards to the native channel instead). */
+    readonly window: UnifiedWindowWake;
+}
+/**
+ * Route one floor-passing Teams activity to the domain's single-window supervisor: get-or-create
+ * the (unified-grain) session, build + render the wake for that generation, and deliver it via
+ * the wake dep (whose live wiring diverts into the unified channel — registering the durable
+ * wakeId→origin map entry BEFORE the send).
+ *
+ * A DELIVERY failure (the enqueue/divert itself) propagates to the caller's catch. A session that
+ * dies at TURN time does not: nothing here observes it, so the trigger is lost SILENTLY, and no
+ * reactive arm can exist (OPE-174 removed the inert one; channels/session-resume.ts holds the
+ * measurement). The working remedy is PRE-DISPATCH — the live `getOrCreateSession` claims the
+ * OPE-599 runtime-change rotation before this call and hands back a session the running eve build
+ * can read.
+ */
+export declare function handleTeamsSingleWindowDispatch(d: TeamsSupervisorDispatch, deps: TeamsSupervisorDeps): Promise<void>;
+/** Everything {@link buildTeamsDmWake} needs — deliberately NARROWER than {@link
+ *  TeamsSupervisorWakeInput}: a DM has no channel container and no engagement tier, and both
+ *  absences are a property of the surface rather than a field a caller might or might not fill in
+ *  (the buildDiscordDmWake discipline). */
+export interface TeamsDmWakeInput {
+    /** The DM conversation id — a DM's whole locus (the envelope's `<channel id>`). */
+    readonly conversationId: string;
+    readonly wakeId: string;
+    /** The OUTGOING generation's recorded TAIL (OPE-794), rendered as this first wake's backscroll.
+     *  Only a FRESH generation's first wake carries one. */
+    readonly tail?: readonly WakeMessageInput[];
+    readonly trigger: {
+        readonly id: string;
+        readonly author: string;
+        readonly authorId: string;
+        readonly sentAt: string;
+        readonly text: string;
+        /** Resolved per-wake trust tier (identity/wake-trust.ts). 🔴 REQUIRED (OPE-596) — the field
+         *  used to default to `principal`, the highest tier, on the reasoning that a DM partner IS the
+         *  seat's principal. That reasoning is about the ROOM, and the tier is about the AUTHOR. See
+         *  {@link TeamsSupervisorWakeInput}'s trigger tier. */
+        readonly trust: WakeTrust;
+    };
+}
+/**
+ * THE 1:1 (and group) DM WAKE for a first-classed Teams DM window (OPE-357) — the Teams twin of
+ * slack-events.ts's `slackDmWake` and discord-gateway.ts's {@link buildTeamsDmWake} sibling
+ * `buildDiscordDmWake`, and it renders through the SAME core renderer with no platform branch, so all
+ * three surfaces' DM envelopes are one dialect.
+ *
+ * ADDRESSING IS `direct-mention`, ALWAYS, doing the same two jobs it does on Slack/Discord. Semantically
+ * it is simply TRUE: everything said in a DM is said to the agent, which is why this path bypasses the
+ * engagement gate and the name-drop judge entirely — a DM IS ALWAYS ANSWERED. Mechanically it is
+ * LOAD-BEARING: `direct-mention` stamps `oe_addressing` through the divert, which marks the wake as
+ * OWED a reply and selects the `[direct]` preamble's reply mandate. 🔴 IT IS NOT A DELIVERY PATH
+ * (OPE-1982): the addressed-prose bridge it used to arm is deleted, so a DM answer written as prose
+ * rather than a `reply` call is DROPPED on that channel like any other, and re-driven once.
+ *
+ * `reason` is `dm`, not `mention`: the envelope's reason describes the SURFACE SHAPE, and it is the
+ * one reason that survives the OPE-744 collapse of `mention` into `channel-activity` — no other
+ * attribute states "this is a direct-message room". NO `engagementTier` either — that dial raises
+ * the bar for AMBIENT watching, and a DM is always answered.
+ *
+ * NO PLATFORM-FETCH BACKSCROLL, EVER — and here that is not merely the native path's choice (as on
+ * Discord) but a platform fact: the Bot Connector exposes no DM message-history read and the Graph
+ * chat-history endpoint is deliberately unwired (teams-read.ts). So a fresh Teams DM generation
+ * carries the RECORDED TAIL and nothing else. Pure → unit-testable.
+ */
+export declare function buildTeamsDmWake(input: TeamsDmWakeInput): NormalizedWake;
+//# sourceMappingURL=teams-supervisor.d.ts.map

package/dist/agent/channels/teams-supervisor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"teams-supervisor.d.ts","sourceRoot":"","sources":["../../../agent/channels/teams-supervisor.ts"],"names":[],"mappings":"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"}