@domino-sdk/relay 1.59.0 → 1.60.0

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @domino-sdk/relay
 
+## 1.60.0
+
+### Minor Changes
+
+- d258795: A budget can cap what one person gives, not only what one member receives. `budget({ key, scope: "author", period, limit, cost })` counts per tracker record author: the account that caused the record, such as a reaction's reactor, whether or not a member linked it. Put it in a tracker quest's `budgets` beside a `"member"` budget to cap both sides, for example a tip paid to a message's author with `beneficiary: "messageAuthor"`: at most 20 tips a day per receiver and 10 a day per reactor. A tip over either cap is rejected with `budget-exhausted`, permanently; other reactors' tips keep paying. It works on `telegram.reactions()`, `discord.reactions()`, kudos recipients and X `inReplyTo` replies. Author budgets share keys, calendar periods and the atomic commit with the other budgets, and imported completions don't count toward them.
+
+  An author budget needs a tracker trigger. `domino check` reports `AUTHOR_BUDGET_TRACKER_REQUIRED` on another quest, `domino build` and `domino deploy` refuse it, and Relay refuses its publication.
+
+  The types SDK 1.x code reads are unchanged: `Budget` keeps `scope: "member" | "project"`, and a quest's description lists author budgets in the new optional `authorBudgets` (`AuthorBudget`, `authorBudgetSchema` from `@domino-sdk/relay/schema`), apart from `budgets`. `budget()` returns an `AuthorBudget` for `scope: "author"`. A member's quest `budgets` (`QuestBudgetView`) leave author budgets out, since they cap someone else's giving.
+
+- d41f5da: `relay.me.get()` and `useMe()` now return the member's `clock: { now, offsetMs }`, the clock Relay judges their activity on. A test member's clock runs ahead after the staging toolbar's **Next day** or `domino test-members advance`; every other member's `offsetMs` is 0. New `memberTime(me, at?)` from `@domino-sdk/relay/browser` turns a real instant into the member's time, so an app that shows campaign phases or open quests by date follows an advanced test member. `clock` is optional, and `memberTime` returns real time when a Relay older than it omits it. On staging, the toolbar's `domino:test-state-changed` event now carries `detail: { change, actingAs }`: what changed and which test member the page is signed in as.
+- e899f47: Member imports carry referrals. A row's optional `referral` names the member's inviter (another row's `ref`, or the sign-in identity of an existing member), when they accepted, and the referral programs they already qualified in (`qualified: [{ program, at }]`). Applying records the referral and the qualifications without paying any referral reward, milestone or bonus; they count toward the inviter's qualified friends, and the friend's later points pay the program's bonus. An inviter's row applies before the rows that name it. New refusal codes: `unknown-inviter`, `self-referral`, `inviter-already-accepted`, `referral-cycle`, `inviter-refused` and `unknown-referral-program`. The check summary adds `referrals` (`accepted`, and `qualified` by program), `management.referrals.participants()` names the import that recorded a relationship or qualification in `import`, and `management.members.get()` returns the member's accepted referral in an optional `referral` (`inviter`, `acceptedAt`, `suspended`, `import`).
+- 8ee2000: A member import vouches for Telegram and Discord accounts too. A row's `accounts` takes `{ kind: "telegram", subject }` and `{ kind: "discord", subject }`, each a numeric user ID, at most one of each per member, from `domino import` and `management.memberImports.addRows`. They work like a vouched X account: Telegram and Discord tracker records, quest checks and Discord role checks trust them from when the import attached them, nobody else can link them, and the member's own Telegram or Discord link replaces them. They never sign in: a Telegram or Discord sign-in with one is refused with `sign-in-method-disabled`. A row naming a second account of a kind, or another one than the member's, is refused with the new `MemberImportRefusalCode.TelegramAccountSelected` (`telegram-account-selected`) or `DiscordAccountSelected` (`discord-account-selected`).
+
+  `@domino-sdk/relay/server` adds `memberImportVouchedAccountSchema`, `memberImportFullRowSchema` and `memberImportFullRowsInputSchema`, with the types `MemberImportVouchedAccount`, `MemberImportFullRow`, `MemberImportFullRowInput` and `MemberImportFullRowsInput`, for rows with every kind of vouched account; `addRows` takes `MemberImportFullRowInput[]`. `memberImportAccountSchema`, `memberImportRowSchema` and `memberImportRowsInputSchema` stay the X-and-wallet form. Member identity states carry `imported: true` for an X, Discord or Telegram account an import attached, and so does a connected `ManagedTelegramAccount`.
+
+  An imported X, Telegram or Discord account now pays tracker records from the moment it was imported. Before, a vouched X account had no link time, so its records were skipped as historical. Members imported before this release keep that unknown link time until they link their X account themselves.
+
+- f0d5b8e: Offers can be archived and restored. `management.offers.archive` and `unarchive` (`POST /management/v1/offers/OFFER/archive|unarchive`), `domino offers archive|unarchive OFFER --reason`, Console **Settings → Resources** and the offer's card in Console **Rewards** archive one in test, and a promotion carries it to live. Each returns `{ resource, changed }`, typed by the new `offerLifecycleResultSchema`, with `resource.kind` `offer`. An archived offer leaves member offer reads and refuses redemption with `offer-paused`; management reads keep it, with the new `archivedAt` field on `Offer`, and its redemptions can still be canceled. `management.resources.list()` and `domino resources list` list offers in a new `offers` array (`managedResourceListSchema`), beside the existing kinds. A rollback now archives an offer the earlier promotion did not carry.
+- 6b5228b: Quests can announce a completion in a connected Telegram chat or Discord channel. List `telegram.postMessage({ chat, text, replyToTriggeringMessage })` or `discord.postMessage({ channel, text, replyToTriggeringMessage })` in the new optional `announcements` of `defineQuest`, beside `rewards` (at most three; an array or a function of the settings). The text is a template with the placeholders `{beneficiary}`, `{author}`, `{points}`, `{rewards}` and `{quest}` (`announcementPlaceholders`); people are mentioned through their linked account on that platform. Relay posts after the rewards commit, as a reward delivery with the new `RewardDeliveryAction.PostMessage` action and an empty `roleId`, retried with backoff and paced per chat; a failed post never undoes the rewards, and `management.retryRewardDelivery(id)` retries one. Descriptions carry them in the new optional `announcements` field (`announcementSchema`). `discord.channels({ postable: true })` lists channels the bot can't post in as unavailable, and `TelegramChat` gains an optional `canPost`. The CLI's authoring reference documents announcements.
+- ea1f033: Revert an applied or stopped member import: `management.memberImports.revert(id, { reason })` starts it, and `domino imports revert IMPORT --reason TEXT` starts it and waits. In the background, one row at a time, it reverses the applied rows' opening balances (taking only points members still have; `unreversedPoints` lists the rest), revokes their imported completions (reason `import-reverted`, freeing the occurrence) and removes the wallets, accounts and identities they linked unless the member signed in with one since (`keptLinks`). Members stay in the project. A reverting or reverted import reads as `applied` with `revert` set, and is reverted once; the same `actionId` answers the import again. Rows applied before imports recorded their links keep them (`linksUntracked`). Reverting needs `publish` permission and works in live from API keys and CLI sessions too. Console shows **Revert import** on applied and stopped imports.
+  `MemberImport` gains `revert`: the reason, who asked and when, rows reverted so far, then `revertedAt` and the `outcome`.
+- 9a7ad11: Stop a member import while it applies: `management.memberImports.stop(id)` and `domino imports stop IMPORT` let the row being applied finish, apply no more rows, and end the import: it reads as `applied` with `appliedAt` null and `stoppedAt` and `stoppedBy` set, and its remaining rows stay `ready`. A stopped import can't be applied again; import the remaining rows in a new import. Stopping needs `publish` permission and works in live from API keys and CLI sessions too. Console shows **Stop import** on an applying import.
+  `MemberImport` gains `stoppedAt` and `stoppedBy`; check `stoppedAt` to tell a stopped import from a fully applied one.
+- df3a08c: A test member's clock moves by hours and minutes, or to an instant, so time-of-day rules can be tested: block edges, or midnight in the project's time zone. `management.testMembers.advance(member, input)` takes `{ actionId }` with one of `days` (1–30, unchanged: project-calendar days that keep the time of day), `hours` (1–720), `minutes` (1–43200) or `to`, an ISO 8601 instant with an offset that must be later than the member's clock (else 422 `test-member-clock-past`). From the CLI, `domino test-members advance MEMBER` takes one of `--days`, `--hours`, `--minutes` or `--to`. The 90-day limit holds across units (422 `test-member-clock-limit`): `days` still add up to at most 90 and land no later than the 90th date, and hours, minutes and `to` never move the clock past 90 days from now. `offsetDays` still counts the days advanced with `days`; hours, minutes and `to` leave it unchanged, so read the member's date from `today`. `@domino-sdk/relay/server` exports `testMemberClockAdvanceSchema` and `TestMemberClockAdvanceInput` for every form; `testMemberAdvanceSchema` and `TestMemberAdvanceInput` stay the `days` form.
+
 ## 1.59.0
 
 ### Minor Changes

package/dist/{accounts-CVonEkdb.d.ts → accounts-DoabriBX.d.ts}

@@ -77,6 +77,7 @@ declare const discordResourceSourceSchema: z.ZodUnion<readonly [z.ZodObject<{
         text: "text";
         announcement: "announcement";
     }>>;
+    postable: z.ZodOptional<z.ZodLiteral<true>>;
 }, z.core.$strict>, z.ZodObject<{
     provider: z.ZodLiteral<"discord">;
     resource: z.ZodLiteral<"role">;
@@ -136,6 +137,7 @@ declare const telegramChatSchema: z.ZodObject<{
     username: z.ZodNullable<z.ZodString>;
     status: z.ZodString;
     issue: z.ZodNullable<z.ZodString>;
+    canPost: z.ZodOptional<z.ZodBoolean>;
     connectedAt: z.ZodNumber;
 }, z.core.$strip>;
 type TelegramChat = z.infer<typeof telegramChatSchema>;
@@ -157,6 +159,7 @@ declare const telegramChatsSchema: z.ZodObject<{
         username: z.ZodNullable<z.ZodString>;
         status: z.ZodString;
         issue: z.ZodNullable<z.ZodString>;
+        canPost: z.ZodOptional<z.ZodBoolean>;
         connectedAt: z.ZodNumber;
     }, z.core.$strip>>;
 }, z.core.$strip>;
@@ -300,4 +303,4 @@ interface DiscordReader {
     }): Promise<DiscordMessage | null>;
 }
 
-export { type AccountConnection as A, discordResourceSourceSchema as B, discordRewardSchema as C, type DiscordMessageData as D, telegramAccountConnectionSchema as E, telegramChatConnectionSchema as F, telegramChatIdSchema as G, telegramChatMemberSchema as H, telegramChatSchema as I, telegramChatsSchema as J, telegramInitDataSchema as K, telegramMemberInputSchema as L, telegramMessageDataSchema as M, telegramMiniAppSignInSchema as N, telegramReactionDataSchema as O, telegramSignInMethodsSchema as P, type TelegramAccountConnection as T, type AuthProvider as a, type TelegramSignInMethods as b, type DiscordMessageTextData as c, discordMessagesSourceSchema as d, discordReactionsSourceSchema as e, type DiscordReactionData as f, type TelegramReader as g, type DiscordReader as h, type TelegramChatMember as i, type TelegramChatMemberStatus as j, type TelegramMessageData as k, type TelegramReactionData as l, type DiscordMember as m, type DiscordMessage as n, type TelegramChat as o, type TelegramChatConnection as p, type TelegramChats as q, accountConnectionSchema as r, authProviderSchema as s, discordMemberInputSchema as t, discordMemberSchema as u, discordMessageDataSchema as v, discordMessageInputSchema as w, discordMessageSchema as x, discordMessageTextDataSchema as y, discordReactionDataSchema as z };
+export { type AccountConnection as A, discordReactionDataSchema as B, discordResourceSourceSchema as C, type DiscordMessageData as D, discordRewardSchema as E, telegramAccountConnectionSchema as F, telegramChatConnectionSchema as G, telegramChatIdSchema as H, telegramChatSchema as I, telegramChatsSchema as J, telegramInitDataSchema as K, telegramMemberInputSchema as L, telegramMessageDataSchema as M, telegramMiniAppSignInSchema as N, telegramReactionDataSchema as O, telegramSignInMethodsSchema as P, type TelegramAccountConnection as T, type AuthProvider as a, type TelegramSignInMethods as b, type DiscordMessageTextData as c, discordMessagesSourceSchema as d, discordReactionsSourceSchema as e, type DiscordReactionData as f, type TelegramReader as g, type DiscordReader as h, type TelegramChatMember as i, type TelegramChatMemberStatus as j, type TelegramMessageData as k, type TelegramReactionData as l, discordMemberSchema as m, discordMessageSchema as n, type DiscordMember as o, type DiscordMessage as p, type TelegramChat as q, type TelegramChatConnection as r, type TelegramChats as s, telegramChatMemberSchema as t, accountConnectionSchema as u, authProviderSchema as v, discordMemberInputSchema as w, discordMessageDataSchema as x, discordMessageInputSchema as y, discordMessageTextDataSchema as z };

package/dist/{attempt-captures-DBj-rxak.d.ts → attempt-captures-W2dgzGqE.d.ts}

@@ -1,4 +1,4 @@
-import { O as OpenIdentityKind } from './schema-BA0nRRlt.js';
+import { O as OpenIdentityKind } from './schema-CwbRkmlr.js';
 import * as z from 'zod';
 
 /** One capability call of the captured evaluation run, as Relay stored it. */

package/dist/authoring.d.ts

@@ -1,23 +1,23 @@
-import { B as xContentBodySchema, I as IdentityKind, C as customSourceSchema, W as WithRecordData, D as WithContent, F as WithAccountRoles, y as ResourceHandle, x as QuestHandle, L as LedgerReference, G as GroupHandle, H as pointLedgerDeclarationSchema, J as TrackerSource, N as trackerDefinitionSchema, U as Tracker, V as TrackerData, X as SourceRoles, Y as LedgerHandle, Z as TrackerDataSchema, _ as xSearchSourceSchema, $ as XTweet, a0 as XContentMetric, a1 as TrackerTriggerPolicy, a2 as Where, a3 as MemberIdentity, P as PointBalance, a4 as ReferralHandle, a5 as TrackerTriggerContext, a6 as TrackerReader, a7 as TextReviewInput, a8 as TextResult, z as PhotoResult, a9 as Decision, aa as rewardSchema, ab as TrackerTriggerMode, ac as RoleOf, ad as WhereSetting, ae as ContentBody, af as BadgeHandle, ag as ContentMetricName, ah as triggerSchema, k as QuestPresentation, l as QuestProfile, m as QuizEvidence, ai as TieredRewardDefinition } from './schema-BA0nRRlt.js';
-export { aj as LedgerSetting, ak as TrackerPage, al as TrackerReadQuery, am as trackerDataSchema, an as trackerTriggerContextSchema } from './schema-BA0nRRlt.js';
-import { M as MemberCompletion, B as Budget } from './capability-error-DDJl0LY-.js';
-export { C as CapabilityError, a as CapabilityErrorCode, c as capabilityErrorCodes } from './capability-error-DDJl0LY-.js';
-import { N as NftCollection, o as ContractCall, p as ContractEvent, S as SolanaProgram, q as WalletBalanceSourceQuery, r as WalletTransaction, s as WalletInstruction, e as ProfileReferral, t as WalletReader } from './wallet-B06zvDXp.js';
-export { u as ContractCallParts, v as ContractCallReturnType, w as ContractEventInput, x as ContractEventParts, y as ContractFunction, z as CosmosDenom, a as CosmosNetwork, E as EvmChainId, B as NftCollectionParts, D as NftStandard, F as WalletBalance, G as WalletBalanceChange, H as WalletBalanceQuery, I as WalletBalanceSample, J as WalletCall, K as WalletCallArgument, M as WalletCallQuery, Q as WalletDelegations, R as WalletDelegationsQuery, T as WalletEventCondition, U as WalletEventValue, V as WalletEvents, X as WalletEventsQuery, Y as WalletNfts, Z as WalletNftsQuery, _ as WalletTransactions, $ as WalletTransactionsQuery, a0 as cosmosDenomSchema, a1 as cosmosNetworkSchema, a2 as isContractCall, a3 as isContractEvent, a4 as isEvmChainId, a5 as isNftCollection, a6 as isSolanaProgram, a7 as maxWalletEventLogs, a8 as maxWalletEventLookback, a9 as maxWalletTransactionLookback, aa as maxWalletTransactions, ab as parseContractCall, ac as parseContractEvent, ad as parseContractFunction, ae as parseNftCollection } from './wallet-B06zvDXp.js';
+import { B as xContentBodySchema, I as IdentityKind, C as customSourceSchema, W as WithRecordData, D as WithContent, F as WithAccountRoles, y as ResourceHandle, x as QuestHandle, L as LedgerReference, G as GroupHandle, H as pointLedgerDeclarationSchema, J as TrackerSource, N as trackerDefinitionSchema, U as Tracker, V as TrackerData, X as SourceRoles, Y as LedgerHandle, Z as TrackerDataSchema, _ as xSearchSourceSchema, $ as XTweet, a0 as XContentMetric, a1 as TrackerTriggerPolicy, a2 as Where, a3 as MemberIdentity, P as PointBalance, a4 as ReferralHandle, a5 as TrackerTriggerContext, a6 as TrackerReader, a7 as TextReviewInput, a8 as TextResult, z as PhotoResult, a9 as Decision, aa as rewardSchema, ab as TrackerTriggerMode, ac as RoleOf, ad as WhereSetting, ae as ContentBody, af as BadgeHandle, ag as ContentMetricName, ah as triggerSchema, k as QuestPresentation, l as QuestProfile, m as QuizEvidence, ai as TieredRewardDefinition } from './schema-CwbRkmlr.js';
+export { aj as LedgerSetting, ak as TrackerPage, al as TrackerReadQuery, am as trackerDataSchema, an as trackerTriggerContextSchema } from './schema-CwbRkmlr.js';
+import { M as MemberCompletion, B as Budget, A as AuthorBudget } from './capability-error-DufwG3G0.js';
+export { C as CapabilityError, a as CapabilityErrorCode, c as capabilityErrorCodes } from './capability-error-DufwG3G0.js';
+import { N as NftCollection, o as ContractCall, p as ContractEvent, S as SolanaProgram, q as WalletBalanceSourceQuery, r as WalletTransaction, s as WalletInstruction, e as ProfileReferral, t as WalletReader } from './wallet-DZWL7lJH.js';
+export { u as ContractCallParts, v as ContractCallReturnType, w as ContractEventInput, x as ContractEventParts, y as ContractFunction, z as CosmosDenom, a as CosmosNetwork, E as EvmChainId, B as NftCollectionParts, D as NftStandard, F as WalletBalance, G as WalletBalanceChange, H as WalletBalanceQuery, I as WalletBalanceSample, J as WalletCall, K as WalletCallArgument, M as WalletCallQuery, Q as WalletDelegations, R as WalletDelegationsQuery, T as WalletEventCondition, U as WalletEventValue, V as WalletEvents, X as WalletEventsQuery, Y as WalletNfts, Z as WalletNftsQuery, _ as WalletTransactions, $ as WalletTransactionsQuery, a0 as cosmosDenomSchema, a1 as cosmosNetworkSchema, a2 as isContractCall, a3 as isContractEvent, a4 as isEvmChainId, a5 as isNftCollection, a6 as isSolanaProgram, a7 as maxWalletEventLogs, a8 as maxWalletEventLookback, a9 as maxWalletTransactionLookback, aa as maxWalletTransactions, ab as parseContractCall, ac as parseContractEvent, ad as parseContractFunction, ae as parseNftCollection } from './wallet-DZWL7lJH.js';
 import * as z from 'zod';
 export { z } from 'zod';
-import { f as badgeDeclarationSchema, B as Badge } from './offers-DAfe1O3_.js';
-export { g as defineOffer } from './offers-DAfe1O3_.js';
-import { E as EngagementBudget, m as leaderboardDefinitionSchema, l as AuthoringIdentity, r as referralAuthoringSchema, C as CampaignDefinition, A as AvailabilityWindow } from './groups-CFuTfFqG.js';
-export { n as defineCampaign, o as defineGroup } from './groups-CFuTfFqG.js';
-import { d as discordMessagesSourceSchema, D as DiscordMessageData, c as DiscordMessageTextData, e as discordReactionsSourceSchema, f as DiscordReactionData, g as TelegramReader, h as DiscordReader } from './accounts-CVonEkdb.js';
-export { i as TelegramChatMember, j as TelegramChatMemberStatus, k as TelegramMessageData, l as TelegramReactionData } from './accounts-CVonEkdb.js';
+import { f as badgeDeclarationSchema, B as Badge } from './offers-CqXfMIxq.js';
+export { g as defineOffer } from './offers-CqXfMIxq.js';
+import { E as EngagementBudget, m as leaderboardDefinitionSchema, l as AuthoringIdentity, r as referralAuthoringSchema, C as CampaignDefinition, A as AvailabilityWindow } from './groups-9Jm3peq3.js';
+export { n as defineCampaign, o as defineGroup } from './groups-9Jm3peq3.js';
+import { d as discordMessagesSourceSchema, D as DiscordMessageData, c as DiscordMessageTextData, e as discordReactionsSourceSchema, f as DiscordReactionData, g as TelegramReader, h as DiscordReader } from './accounts-DoabriBX.js';
+export { i as TelegramChatMember, j as TelegramChatMemberStatus, k as TelegramMessageData, l as TelegramReactionData } from './accounts-DoabriBX.js';
 import { a as StreakPolicy, Q as QuizContent } from './streaks-0YuipsUQ.js';
-import { R as ResourceSource, S as Setting, A as AmountSetting, B as BalanceChain, I as IntegrationModule, a as BoundSettings } from './integrations-DrbKQSTD.js';
-export { D as DashboardInput, b as DashboardPanelInput, T as TikTokVideoBody, c as TikTokVideoMetric, Y as YouTubeShortBody, d as YouTubeShortMetric, e as defineDashboard } from './integrations-DrbKQSTD.js';
-import { P as Prerequisite, T as TextEvidence, U as UrlEvidence, a as TextOptions, b as UrlOptions } from './submission-input-DxQ6RnKo.js';
-export { c as balanceAtLeast, d as completed, i as inGroup } from './submission-input-DxQ6RnKo.js';
-import { I as ImageReader, X as XReader } from './x-C28SNifw.js';
+import { R as ResourceSource, S as Setting, A as AmountSetting, B as BalanceChain, I as IntegrationModule, a as BoundSettings, b as Announcement } from './integrations-CmIkP1Gi.js';
+export { D as DashboardInput, c as DashboardPanelInput, T as TikTokVideoBody, d as TikTokVideoMetric, Y as YouTubeShortBody, e as YouTubeShortMetric, f as defineDashboard } from './integrations-CmIkP1Gi.js';
+import { P as Prerequisite, T as TextEvidence, U as UrlEvidence, a as TextOptions, b as UrlOptions } from './submission-input-D9EGH_yb.js';
+export { c as balanceAtLeast, d as completed, i as inGroup } from './submission-input-D9EGH_yb.js';
+import { I as ImageReader, X as XReader } from './x-KFJD2x8y.js';
 export { f as formatUnits, p as parseUnits } from './units-CwgsPB_r.js';
 import './analytics-URV-mxjH.js';
 
@@ -446,13 +446,36 @@ declare const discord: {
         action: "grant-role";
         roleId: string;
     };
+    /**
+     * An announcement Domino's bot posts in a channel of the project's Discord server when a
+     * completion pays, such as `"{beneficiary} got +{points} XP from {author}"`. Placeholders are
+     * `announcementPlaceholders`; `{beneficiary}` and `{author}` mention linked Discord accounts.
+     * Pass it in the quest's `announcements`, and declare the `discord` integration.
+     */
+    postMessage(options: {
+        channel: string;
+        text: string;
+        replyToTriggeringMessage?: boolean;
+    }): {
+        action: "post-message";
+        text: string;
+        provider: "discord";
+        channel: string;
+        replyToTriggeringMessage?: boolean | undefined;
+    };
     messages: typeof messages;
     reactions: typeof reactions;
     roles(options?: {
         assignable?: boolean;
     }): ResourceSource;
+    /**
+     * A channel of the project's Discord server, for a resource setting. With `postable: true`,
+     * Console lists channels Domino's bot cannot post in as unavailable, as an announcement's
+     * channel needs.
+     */
     channels(options?: {
         types?: ChannelTypes;
+        postable?: boolean;
     }): ResourceSource;
 };
 /**
@@ -470,11 +493,30 @@ declare const discord: {
  *   Pay the message's author with `automatic({ tracker, beneficiary: "messageAuthor" })`.
  * - Quests read membership with `ctx.telegram.member({ chat })`, naming the chat with
  *   `settings.telegramChat()`.
+ * - `telegram.postMessage({ chat, text })`: an announcement the bot posts in a connected chat
+ *   when a completion pays, listed in the quest's `announcements`.
  *
  * In SDK 1.x both sources are custom sources whose namespaces Relay reserves: only Relay writes
  * their records, and the accounts on them are Telegram accounts whatever `identities` says.
  */
 declare const telegram: {
+    /**
+     * An announcement Domino's bot posts in a connected chat when a completion pays, such as
+     * `"{beneficiary} got +{points} XP from {author}"`. Name the chat with `settings.telegramChat()`.
+     * Placeholders are `announcementPlaceholders`; `{beneficiary}` and `{author}` mention Telegram
+     * accounts. Pass it in the quest's `announcements`.
+     */
+    postMessage(options: {
+        chat: string;
+        text: string;
+        replyToTriggeringMessage?: boolean;
+    }): {
+        action: "post-message";
+        text: string;
+        provider: "telegram";
+        chat: string;
+        replyToTriggeringMessage?: boolean | undefined;
+    };
     messages(): {
         kind: "custom";
         namespace: string;
@@ -1068,19 +1110,21 @@ type QuestKeyedContext<S, G> = Omit<KeyedContext, "tracker"> & {
     /** The pinned tracker observation: non-null and typed for a tracker trigger, null for others. */
     tracker: ContextTracker<G>;
 };
-declare const budget: (definition: Omit<Budget, "id" | "cost"> & {
+type BudgetDefinition<B extends Budget | AuthorBudget> = Omit<B, "id" | "cost"> & {
     key: string;
     cost: number | {
         ledger: LedgerReference;
     };
-}) => {
-    id: string;
-    scope: "member" | "project";
-    period: "lifetime" | "day" | "week" | "month";
-    limit: number;
-    cost: number | {
-        balance: string;
-    };
+};
+/**
+ * A named cap on a quest's completions or awarded points, per member (`scope: "member"`), for
+ * everyone together (`"project"`), or per tracker record author (`"author"`): the account that
+ * caused the record, such as a reaction's reactor, whether or not a member linked it. An author
+ * budget caps what one person gives when the quest pays someone else, and needs a tracker trigger.
+ */
+declare const budget: {
+    (definition: BudgetDefinition<Budget>): Budget;
+    (definition: BudgetDefinition<AuthorBudget>): AuthorBudget;
 };
 declare const keyed: (key: (ctx: KeyedContext) => string) => {
     kind: "keyed";
@@ -1464,7 +1508,8 @@ declare const defineQuest: <T extends Record<string, Setting>, const G extends T
      * (`relay.profiles.completions`). Hidden by default.
      */
     profile?: QuestProfile;
-    budgets?: Budget[];
+    /** Its {@link budget}s; an author budget needs a tracker trigger. */
+    budgets?: (Budget | AuthorBudget)[];
     /**
      * Milliseconds a member waits after an attempt is rejected, by the evaluator or a
      * reviewer, before submitting again: `300_000` lets a quiz be retried every five minutes.
@@ -1522,6 +1567,26 @@ declare const defineQuest: <T extends Record<string, Setting>, const G extends T
     })[] | ((ctx: {
         settings: z.core.$InferObjectOutput<T, {}>;
     }) => Reward[]);
+    /**
+     * Messages Relay posts when a completion pays, after its rewards commit, such as
+     * `telegram.postMessage({ chat, text: "{beneficiary} got +{points} XP from {author}" })`.
+     * At most three. Return none while a setting they need is empty.
+     */
+    announcements?: ({
+        action: "post-message";
+        text: string;
+        provider: "telegram";
+        chat: string;
+        replyToTriggeringMessage?: boolean | undefined;
+    } | {
+        action: "post-message";
+        text: string;
+        provider: "discord";
+        channel: string;
+        replyToTriggeringMessage?: boolean | undefined;
+    })[] | ((ctx: {
+        settings: z.core.$InferObjectOutput<T, {}>;
+    }) => Announcement[]) | undefined;
     evaluate?: Evaluator<z.core.$InferObjectOutput<T, {}>, QuestInput<G>, NoInfer<G>, NoInfer<D>> | undefined;
     /**
      * A content quest's performance stage: once content evaluation accepts an item, each later
@@ -1596,6 +1661,7 @@ declare const defineQuest: <T extends Record<string, Setting>, const G extends T
                 provider: "discord";
                 resource: "channel";
                 types: ("text" | "announcement")[];
+                postable?: true | undefined;
             } | {
                 provider: "discord";
                 resource: "role";
@@ -1814,6 +1880,19 @@ declare const defineQuest: <T extends Record<string, Setting>, const G extends T
                 balance: string;
             };
         }[];
+        announcements?: ({
+            action: "post-message";
+            text: string;
+            provider: "telegram";
+            chat: string;
+            replyToTriggeringMessage?: boolean | undefined;
+        } | {
+            action: "post-message";
+            text: string;
+            provider: "discord";
+            channel: string;
+            replyToTriggeringMessage?: boolean | undefined;
+        })[] | undefined;
         performance?: {
             metrics: string[];
             maxAgeMs: number;
@@ -1831,6 +1910,15 @@ declare const defineQuest: <T extends Record<string, Setting>, const G extends T
             from: number;
             until: number;
         } | undefined;
+        authorBudgets?: {
+            id: string;
+            period: "lifetime" | "day" | "week" | "month";
+            limit: number;
+            cost: number | {
+                balance: string;
+            };
+            scope: "author";
+        }[] | undefined;
         retryCooldownMs?: number | undefined;
         completionCooldownMs?: number | undefined;
     };
@@ -1914,7 +2002,8 @@ declare const defineQuestType: <T extends Record<string, Setting>, const G exten
      * (`relay.profiles.completions`). Hidden by default.
      */
     profile?: QuestProfile;
-    budgets?: Budget[];
+    /** Its {@link budget}s; an author budget needs a tracker trigger. */
+    budgets?: (Budget | AuthorBudget)[];
     /**
      * Milliseconds a member waits after an attempt is rejected, by the evaluator or a
      * reviewer, before submitting again: `300_000` lets a quiz be retried every five minutes.
@@ -1972,6 +2061,26 @@ declare const defineQuestType: <T extends Record<string, Setting>, const G exten
     })[] | ((ctx: {
         settings: z.core.$InferObjectOutput<T, {}>;
     }) => Reward[]);
+    /**
+     * Messages Relay posts when a completion pays, after its rewards commit, such as
+     * `telegram.postMessage({ chat, text: "{beneficiary} got +{points} XP from {author}" })`.
+     * At most three. Return none while a setting they need is empty.
+     */
+    announcements?: ({
+        action: "post-message";
+        text: string;
+        provider: "telegram";
+        chat: string;
+        replyToTriggeringMessage?: boolean | undefined;
+    } | {
+        action: "post-message";
+        text: string;
+        provider: "discord";
+        channel: string;
+        replyToTriggeringMessage?: boolean | undefined;
+    })[] | ((ctx: {
+        settings: z.core.$InferObjectOutput<T, {}>;
+    }) => Announcement[]) | undefined;
     evaluate?: Evaluator<z.core.$InferObjectOutput<T, {}>, QuestInput<G>, NoInfer<G>, NoInfer<D>> | undefined;
     /**
      * A content quest's performance stage: once content evaluation accepts an item, each later
@@ -2046,6 +2155,7 @@ declare const defineQuestType: <T extends Record<string, Setting>, const G exten
                 provider: "discord";
                 resource: "channel";
                 types: ("text" | "announcement")[];
+                postable?: true | undefined;
             } | {
                 provider: "discord";
                 resource: "role";
@@ -2264,6 +2374,19 @@ declare const defineQuestType: <T extends Record<string, Setting>, const G exten
                 balance: string;
             };
         }[];
+        announcements?: ({
+            action: "post-message";
+            text: string;
+            provider: "telegram";
+            chat: string;
+            replyToTriggeringMessage?: boolean | undefined;
+        } | {
+            action: "post-message";
+            text: string;
+            provider: "discord";
+            channel: string;
+            replyToTriggeringMessage?: boolean | undefined;
+        })[] | undefined;
         performance?: {
             metrics: string[];
             maxAgeMs: number;
@@ -2281,6 +2404,15 @@ declare const defineQuestType: <T extends Record<string, Setting>, const G exten
             from: number;
             until: number;
         } | undefined;
+        authorBudgets?: {
+            id: string;
+            period: "lifetime" | "day" | "week" | "month";
+            limit: number;
+            cost: number | {
+                balance: string;
+            };
+            scope: "author";
+        }[] | undefined;
         retryCooldownMs?: number | undefined;
         completionCooldownMs?: number | undefined;
     };

package/dist/authoring.js

@@ -8,7 +8,7 @@ import {
   tiktokVideoMetrics,
   youtubeShortBodySchema,
   youtubeShortMetrics
-} from "./chunk-W42KMMH5.js";
+} from "./chunk-N3LJ6GFK.js";
 import {
   CapabilityError,
   capabilityErrorCodes
@@ -17,7 +17,7 @@ import {
   sourceDataSchema,
   sourceRoles,
   validateQuestShape
-} from "./chunk-YMWRLAAP.js";
+} from "./chunk-VWMIA2TT.js";
 import {
   badgeDeclarationSchema,
   defineOffer,
@@ -26,13 +26,13 @@ import {
   engagementScoreSchema,
   leaderboardAuthoringSchema,
   referralAuthoringSchema
-} from "./chunk-UEMLYPKJ.js";
+} from "./chunk-MJEJQH5A.js";
 import {
-  pointLedgerDeclarationSchema,
-  telegramMessageDataSchema,
-  telegramReactionDataSchema
-} from "./chunk-XGXDINGM.js";
+  pointLedgerDeclarationSchema
+} from "./chunk-YNW2ZUUP.js";
 import {
+  announcementSchema,
+  authorBudgetSchema,
   authoringKey,
   badgeReward,
   balanceAtLeast,
@@ -51,6 +51,7 @@ import {
   defaultTriggerMode,
   defineCampaign,
   defineGroup,
+  discordAnnouncementSchema,
   discordMessagesSourceSchema,
   discordReactionsSourceSchema,
   discordRewardSchema,
@@ -73,6 +74,7 @@ import {
   maxWalletEventLookback,
   maxWalletTransactionLookback,
   maxWalletTransactions,
+  parseAnnouncementTemplate,
   parseContractCall,
   parseContractEvent,
   parseContractFunction,
@@ -96,7 +98,10 @@ import {
   sourceContent,
   sourceIdentities,
   streakPolicySchema,
+  telegramAnnouncementSchema,
+  telegramMessageDataSchema,
   telegramMessagesNamespace,
+  telegramReactionDataSchema,
   telegramReactionsNamespace,
   textOptionsSchema,
   textSettingSchema,
@@ -115,7 +120,7 @@ import {
   whereSettings,
   xSearchSourceSchema,
   youtubeShortsNamespace
-} from "./chunk-AWWCEP7F.js";
+} from "./chunk-GBSDAD3N.js";
 
 // src/builders.ts
 import * as z from "zod";
@@ -292,6 +297,19 @@ var discord = {
     action: "grant-role",
     roleId
   }),
+  /**
+   * An announcement Domino's bot posts in a channel of the project's Discord server when a
+   * completion pays, such as `"{beneficiary} got +{points} XP from {author}"`. Placeholders are
+   * `announcementPlaceholders`; `{beneficiary}` and `{author}` mention linked Discord accounts.
+   * Pass it in the quest's `announcements`, and declare the `discord` integration.
+   */
+  postMessage(options) {
+    return discordAnnouncementSchema.parse({
+      provider: "discord",
+      action: "post-message",
+      ...options
+    });
+  },
   messages,
   reactions,
   roles(options = {}) {
@@ -301,15 +319,34 @@ var discord = {
       assignable: options.assignable ?? false
     });
   },
+  /**
+   * A channel of the project's Discord server, for a resource setting. With `postable: true`,
+   * Console lists channels Domino's bot cannot post in as unavailable, as an announcement's
+   * channel needs.
+   */
   channels(options = {}) {
     return resourceSourceSchema.parse({
       provider: "discord",
       resource: "channel",
-      types: options.types ?? ["text", "announcement"]
+      types: options.types ?? ["text", "announcement"],
+      ...options.postable ? { postable: true } : {}
     });
   }
 };
 var telegram = {
+  /**
+   * An announcement Domino's bot posts in a connected chat when a completion pays, such as
+   * `"{beneficiary} got +{points} XP from {author}"`. Name the chat with `settings.telegramChat()`.
+   * Placeholders are `announcementPlaceholders`; `{beneficiary}` and `{author}` mention Telegram
+   * accounts. Pass it in the quest's `announcements`.
+   */
+  postMessage(options) {
+    return telegramAnnouncementSchema.parse({
+      provider: "telegram",
+      action: "post-message",
+      ...options
+    });
+  },
   messages() {
     return customSource(telegramMessagesNamespace, {
       identities: ["member"],
@@ -801,14 +838,17 @@ function content(input) {
   }
   return trackerTrigger({ ...input, content: true }, "content");
 }
-var budget = (definition) => {
+function defineBudget(definition) {
   const { key: _, cost, ...properties } = definition;
-  return budgetSchema.parse({
+  const parsed = {
     ...properties,
     id: authoringKey(definition),
     cost: typeof cost === "number" ? cost : { balance: ledgerKey(cost.ledger) }
-  });
-};
+  };
+  return properties.scope === "author" ? authorBudgetSchema.parse(parsed) : budgetSchema.parse(parsed);
+}
+var budget = defineBudget;
+var authorBudgets = (budgets = []) => budgets.filter((value) => value.scope === "author");
 var keyed = (key) => ({
   kind: "keyed",
   key
@@ -928,11 +968,13 @@ function questBuilder(template) {
         "A quest needs a completion, such as once(), keyed(...), streak(...) or progress(...)"
       );
     }
+    const author = authorBudgets(definition.budgets);
     validateQuestShape(
       {
         trigger: definition.trigger,
         completion: completion ?? { kind: "keyed" },
         requires: definition.requires ?? [],
+        authorBudgets: author,
         performance: definition.performance ? contentPerformancePolicySchema.parse({
           metrics: definition.performance.metrics,
           maxAgeMs: definition.performance.maxAgeMs
@@ -992,10 +1034,33 @@ function questBuilder(template) {
       const rewards = rewardBundleSchema.parse(
         typeof definition.rewards === "function" ? definition.rewards({ settings: settings2 }) : definition.rewards
       );
+      const announcements = z3.array(announcementSchema).max(3, "A quest posts at most three announcements").parse(
+        (typeof definition.announcements === "function" ? definition.announcements({ settings: settings2 }) : definition.announcements) ?? []
+      );
+      const trackerTrigger3 = definition.trigger.kind === "automatic" && definition.trigger.tracker !== void 0;
+      for (const announcement of announcements) {
+        const parsed = parseAnnouncementTemplate(announcement.text);
+        const usesAuthor = "segments" in parsed && parsed.segments.some(
+          (segment) => segment.kind === "placeholder" && segment.name === "author"
+        );
+        if (!trackerTrigger3 && usesAuthor) {
+          throw new Error(
+            "An announcement names {author} only on a quest with an automatic tracker trigger"
+          );
+        }
+        if (!trackerTrigger3 && announcement.replyToTriggeringMessage) {
+          throw new Error(
+            "An announcement replies to the triggering message only on a quest with an automatic tracker trigger"
+          );
+        }
+      }
       const required = [
         ...rewards.flatMap(
           (reward) => reward.kind === "integration" ? [reward.provider] : []
         ),
+        ...announcements.flatMap(
+          (announcement) => announcement.provider === "discord" ? ["discord"] : []
+        ),
         ...Object.values(fields).flatMap(
           (field) => field.kind === "resource" && field.source.provider !== "domino" ? [field.source.provider] : []
         )
@@ -1013,6 +1078,7 @@ function questBuilder(template) {
         fields,
         values,
         rewards,
+        ...announcements.length ? { announcements } : {},
         humanReview: definition.review?.({ settings: settings2 })?.enabled ?? true,
         trigger: definition.trigger,
         ...definition.performance ? {
@@ -1031,7 +1097,10 @@ function questBuilder(template) {
         } : completion.kind === "streak" ? completion : { kind: completion.kind },
         visibility: definition.visibility ?? "visible",
         profile: definition.profile ?? { visible: false },
-        budgets: definition.budgets ?? [],
+        budgets: (definition.budgets ?? []).filter(
+          (value) => value.scope !== "author"
+        ),
+        ...author.length ? { authorBudgets: author } : {},
         requires: definition.requires ?? [],
         ...definition.campaign ? { campaign: definition.campaign } : {},
         ...definition.availability ? { availability: definition.availability } : {},

package/dist/{automatic-outcomes-FS9okvBP.d.ts → automatic-outcomes-Cmou89IS.d.ts}

@@ -1,5 +1,5 @@
 import * as z from 'zod';
-import { a as AttemptStatus } from './schema-BA0nRRlt.js';
+import { a as AttemptStatus } from './schema-CwbRkmlr.js';
 
 declare const collectionCodeSchema: z.ZodString;
 declare const collectionPassSchema: z.ZodObject<{

package/dist/avatar.d.ts

@@ -1,4 +1,4 @@
-import { P as ProfileAvatar, L as LinkedWallet } from './wallet-B06zvDXp.js';
+import { P as ProfileAvatar, L as LinkedWallet } from './wallet-DZWL7lJH.js';
 import 'zod';
 
 /**