@domino-sdk/relay 1.59.0 → 1.61.0

package/CHANGELOG.md

@@ -1,5 +1,50 @@
 # @domino-sdk/relay
 
+## 1.61.0
+
+### Minor Changes
+
+- f0ce453: `RelayProvider` follows the EVM wallet a participant signed in with through `useSignIn().withWallet()` or a wallet option of `useSignInOptions()`, so the starters need no code for it. When the wallet switches to another account (`accountsChanged`, compared case-insensitively) or reports none because it was locked or disconnected, the provider signs out as `useSignOut()` does and the app shows its sign-in again; it does not sign the new account in. The same account, including the event wallets send on first connect, changes nothing. After a reload the provider finds the wallet again by name and checks `eth_accounts` without a prompt. `WalletSigner` gains an optional `watchAccounts(listener)`, which `evmSigner()` implements, and `Eip1193Provider` an optional `on` and `removeListener`.
+- b369a75: A project connects a Discord server that another project of its organization already connects, ready, in the same environment, without installing Domino's bot again. Any credential with `publish` permission can: an automation key, a CLI session, a personal API key or Console (**Integrations**, **Or reuse**). Installing the bot into a new server stays with an organization administrator in Console.
+
+  - `management.discord.servers()` and `domino integrations discord servers` list the servers the project can connect.
+  - `management.discord.connect(server)` and `domino integrations discord connect --server <id>` connect one, once the bot still sees it. They refuse with 409 `server-not-connected-in-organization` for any other server, 409 `integration-connected` when the project already has a Discord connection, and 422 `server-not-reachable` when the bot lost the server. Connecting the server the project already connects changes nothing.
+  - `management.discord.connection()` and `domino integrations discord status` read the project's Discord connection.
+
+  The project's audit records each connection as `discord-server-connected`, with who connected it and the project whose connection it reused. An automation key and a CLI session connect only in test.
+
+### Patch Changes
+
+- e71f881: `domino check` runs each badge, point ledger, offer, leaderboard, referral, dashboard and tracker entry in a separate Node process and parses its export with the schema Relay parses it with at deployment. A definition that fails, such as an offer without `stock`, reports a `DEFINITION_INVALID` error diagnostic with its `file`, `export`, field `path` and message, and fails the check instead of failing later in staging.
+  `defineOffer`, `defineBadge`, `defineLedger`, `defineLeaderboard`, `defineReferral`, `defineDashboard` and `defineTracker` still throw a `ZodError` for invalid input, and its message now names the kind, key and fields, for example `Offer "ladder" is invalid: stock: Invalid input: expected number, received undefined`. Staging shows that message when its data setup fails.
+  A deployment, preview or staging activation with an inline or described definition that fails its schema now answers 422 `validation-failed` with that message, where it answered 400 `Invalid request`.
+
+## 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/{integrations-DrbKQSTD.d.ts → announcements-CHx3-HBw.d.ts}

@@ -1,7 +1,7 @@
 import * as z from 'zod';
-import { H as WalletBalanceQuery } from './wallet-B06zvDXp.js';
-import { y as ResourceHandle } from './schema-BA0nRRlt.js';
-import { A as AnalyticsMetricId, a as analyticsCatalog } from './analytics-URV-mxjH.js';
+import { H as WalletBalanceQuery } from './wallet-CIqFoxdm.js';
+import { y as ResourceHandle } from './schema-CZ6Rj0ZF.js';
+import { A as AnalyticsMetricId, a as analyticsCatalog } from './integrations-B3y36OaB.js';
 
 declare const resourceSourceSchema: z.ZodUnion<readonly [z.ZodObject<{
     provider: z.ZodLiteral<"domino">;
@@ -13,6 +13,7 @@ declare const resourceSourceSchema: 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">;
@@ -30,6 +31,7 @@ declare const resourceRequestSchema: 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">;
@@ -76,6 +78,7 @@ declare const settingFieldSchema: z.ZodDiscriminatedUnion<[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">;
@@ -149,6 +152,7 @@ declare const settingsFieldsSchema: z.ZodRecord<z.ZodString, z.ZodDiscriminatedU
             text: "text";
             announcement: "announcement";
         }>>;
+        postable: z.ZodOptional<z.ZodLiteral<true>>;
     }, z.core.$strict>, z.ZodObject<{
         provider: z.ZodLiteral<"discord">;
         resource: z.ZodLiteral<"role">;
@@ -562,43 +566,45 @@ declare function defineDashboard(input: DashboardInput): {
     position?: number | undefined;
 } & ResourceHandle<"dashboard">;
 
-/** Modules a quest can declare to enable provider readers. Project connections are separate. */
-declare const evaluatorIntegrationProviderSchema: z.ZodEnum<{
-    discord: "discord";
-    x: "x";
-}>;
-type EvaluatorIntegrationProvider = z.infer<typeof evaluatorIntegrationProviderSchema>;
-type IntegrationModule = {
-    readonly provider: EvaluatorIntegrationProvider;
-};
-declare const integrationProviderSchema: z.ZodEnum<{
-    discord: "discord";
-}>;
-type IntegrationProvider = z.infer<typeof integrationProviderSchema>;
-declare const discordServerSchema: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    icon: z.ZodNullable<z.ZodString>;
-}, z.core.$strip>;
-declare const projectIntegrationSchema: z.ZodObject<{
-    provider: z.ZodEnum<{
-        discord: "discord";
-    }>;
-    configured: z.ZodBoolean;
-    status: z.ZodEnum<{
-        disconnected: "disconnected";
-        ready: "ready";
-        attention: "attention";
-    }>;
-    revision: z.ZodNumber;
-    server: z.ZodNullable<z.ZodObject<{
-        id: z.ZodString;
-        name: z.ZodString;
-        icon: z.ZodNullable<z.ZodString>;
-    }, z.core.$strip>>;
-    issue: z.ZodNullable<z.ZodString>;
-    connectedAt: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strip>;
-type ProjectIntegration = z.infer<typeof projectIntegrationSchema>;
+/**
+ * An announcement's text, at most 1000 characters, with `{placeholder}`s (`announcementPlaceholders`)
+ * that Relay fills when it posts. `{{` and `}}` are literal braces.
+ */
+declare const announcementTextSchema: z.ZodString;
+/** An announcement Domino's bot posts in one of the project's connected Telegram chats. */
+declare const telegramAnnouncementSchema: z.ZodObject<{
+    action: z.ZodLiteral<"post-message">;
+    text: z.ZodString;
+    replyToTriggeringMessage: z.ZodOptional<z.ZodBoolean>;
+    provider: z.ZodLiteral<"telegram">;
+    chat: z.ZodString;
+}, z.core.$strict>;
+/** An announcement Domino's bot posts in a channel of the project's connected Discord server. */
+declare const discordAnnouncementSchema: z.ZodObject<{
+    action: z.ZodLiteral<"post-message">;
+    text: z.ZodString;
+    replyToTriggeringMessage: z.ZodOptional<z.ZodBoolean>;
+    provider: z.ZodLiteral<"discord">;
+    channel: z.ZodString;
+}, z.core.$strict>;
+/**
+ * A message Relay posts when a completion of the quest pays, after its rewards commit. A failed
+ * post never undoes the rewards. Build one with `telegram.postMessage()` or
+ * `discord.postMessage()`.
+ */
+declare const announcementSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"post-message">;
+    text: z.ZodString;
+    replyToTriggeringMessage: z.ZodOptional<z.ZodBoolean>;
+    provider: z.ZodLiteral<"telegram">;
+    chat: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"post-message">;
+    text: z.ZodString;
+    replyToTriggeringMessage: z.ZodOptional<z.ZodBoolean>;
+    provider: z.ZodLiteral<"discord">;
+    channel: z.ZodString;
+}, z.core.$strict>], "provider">;
+type Announcement = z.infer<typeof announcementSchema>;
 
-export { tiktokVideoMetrics as $, type AmountSetting as A, type BalanceChain as B, evaluatorIntegrationProviderSchema as C, type DashboardInput as D, type EvaluatorIntegrationProvider as E, integrationProviderSchema as F, isAmount as G, isBalanceChain as H, type IntegrationModule as I, isBoundSetting as J, missingResourceSettings as K, normalizeDashboard as L, parseSettings as M, projectIntegrationSchema as N, resourceOptionsSchema as O, type ProjectIntegration as P, resourceRequestSchema as Q, type ResourceSource as R, type Setting as S, type TikTokVideoBody as T, resourceSourceSchema as U, settingFieldSchema as V, settingsFieldsSchema as W, settingsValuesSchema as X, type YouTubeShortBody as Y, textSettingSchema as Z, tiktokVideoBodySchema as _, type BoundSettings as a, youtubeShortBodySchema as a0, youtubeShortMetrics as a1, type DashboardPanelInput as b, type TikTokVideoMetric as c, type YouTubeShortMetric as d, defineDashboard as e, type DashboardAuthoring as f, type DashboardDefinition as g, type DashboardIssue as h, type DashboardPanel as i, type DashboardPreview as j, type IntegerSettings as k, type IntegrationProvider as l, type ResourceOption as m, type SettingField as n, type SettingsValues as o, compatibleSettingKinds as p, dashboardArtifactSchema as q, dashboardAuthoringSchema as r, dashboardDefinitionSchema as s, dashboardIssue as t, dashboardLimits as u, dashboardPanelAuthoringSchema as v, dashboardPanels as w, dashboardPreviewSchema as x, defaultPanelWidths as y, discordServerSchema as z };
+export { type AmountSetting as A, type BalanceChain as B, discordAnnouncementSchema as C, type DashboardInput as D, isAmount as E, isBalanceChain as F, isBoundSetting as G, missingResourceSettings as H, type IntegerSettings as I, normalizeDashboard as J, parseSettings as K, resourceOptionsSchema as L, resourceRequestSchema as M, resourceSourceSchema as N, settingFieldSchema as O, settingsFieldsSchema as P, settingsValuesSchema as Q, type ResourceSource as R, type Setting as S, type TikTokVideoBody as T, telegramAnnouncementSchema as U, textSettingSchema as V, tiktokVideoBodySchema as W, tiktokVideoMetrics as X, type YouTubeShortBody as Y, youtubeShortBodySchema as Z, youtubeShortMetrics as _, type BoundSettings as a, type Announcement as b, type DashboardPanelInput as c, type TikTokVideoMetric as d, type YouTubeShortMetric as e, defineDashboard as f, type DashboardAuthoring as g, type DashboardDefinition as h, type DashboardIssue as i, type DashboardPanel as j, type DashboardPreview as k, type ResourceOption as l, type SettingField as m, type SettingsValues as n, announcementSchema as o, announcementTextSchema as p, compatibleSettingKinds as q, dashboardArtifactSchema as r, dashboardAuthoringSchema as s, dashboardDefinitionSchema as t, dashboardIssue as u, dashboardLimits as v, dashboardPanelAuthoringSchema as w, dashboardPanels as x, dashboardPreviewSchema as y, defaultPanelWidths as z };

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

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

package/dist/authoring.d.ts

@@ -1,25 +1,25 @@
-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-CZ6Rj0ZF.js';
+export { aj as LedgerSetting, ak as TrackerPage, al as TrackerReadQuery, am as trackerDataSchema, an as trackerTriggerContextSchema } from './schema-CZ6Rj0ZF.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-CIqFoxdm.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-CIqFoxdm.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-BoV4ryUc.js';
+export { g as defineOffer } from './offers-BoV4ryUc.js';
+import { E as EngagementBudget, m as leaderboardDefinitionSchema, l as AuthoringIdentity, r as referralAuthoringSchema, C as CampaignDefinition, A as AvailabilityWindow } from './groups-CqcA2Ycs.js';
+export { n as defineCampaign, o as defineGroup } from './groups-CqcA2Ycs.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, a as BoundSettings, b as Announcement } from './announcements-CHx3-HBw.js';
+export { D as DashboardInput, c as DashboardPanelInput, T as TikTokVideoBody, d as TikTokVideoMetric, Y as YouTubeShortBody, e as YouTubeShortMetric, f as defineDashboard } from './announcements-CHx3-HBw.js';
+import { P as Prerequisite, T as TextEvidence, U as UrlEvidence, a as TextOptions, b as UrlOptions } from './submission-input-C54Q8yAD.js';
+export { c as balanceAtLeast, d as completed, i as inGroup } from './submission-input-C54Q8yAD.js';
+import { I as ImageReader, X as XReader } from './x-D1PGi8Sq.js';
+import { I as IntegrationModule } from './integrations-B3y36OaB.js';
 export { f as formatUnits, p as parseUnits } from './units-CwgsPB_r.js';
-import './analytics-URV-mxjH.js';
 
 declare function defineBadge(input: z.input<typeof badgeDeclarationSchema>): {
     name: string;
@@ -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;
     };