@zaflun/lumio-protocol 0.6.0 → 0.9.0

package/dist/index.js

@@ -37,7 +37,7 @@ var extensionConfigSchema = z.object({
   extension_id: z.string(),
   install_id: z.string(),
   account_id: z.string(),
-  target: z.enum(["editor", "layer", "interactive"]),
+  target: z.enum(["editor", "layer"]),
   permissions: z.array(z.string()),
   settings: z.record(z.string(), z.unknown())
 });
@@ -120,11 +120,18 @@ var LUMIO_EVENT_TYPES = [
   // Twitch
   "twitch:follower",
   "twitch:subscribe",
-  "twitch:gift_sub",
+  "twitch:gift",
   "twitch:resub",
   "twitch:cheer",
   "twitch:raid",
   "twitch:reward",
+  // Redemption status change (fulfilled / canceled) and reward lifecycle
+  // (created / updated / deleted on Twitch) — ZAF-2393. The lifecycle types are
+  // live-only (`broadcast_only`), never in the event history.
+  "twitch:reward_status",
+  "twitch:reward_add",
+  "twitch:reward_update",
+  "twitch:reward_remove",
   "twitch:hype_train",
   "twitch:hype_train_end",
   "twitch:poll",
@@ -224,6 +231,648 @@ var STORAGE_SCOPES = [
 ];
 var storageScopeSchema = z2.enum(STORAGE_SCOPES);
 
+// src/event-payloads.ts
+import { z as z3 } from "zod/v4";
+var str = z3.string();
+var num = z3.number();
+var bool = z3.boolean();
+var nullableStr = z3.string().nullable();
+var twitchBroadcaster = {
+  broadcaster_user_id: str,
+  broadcaster_user_login: str,
+  broadcaster_user_name: str
+};
+var twitchUser = {
+  user_id: str,
+  user_login: str,
+  user_name: str
+};
+var avatarUrl = { avatarUrl: str.optional() };
+var twitchBadge = z3.looseObject({ set_id: str, id: str, info: str });
+var twitchChatNotice = {
+  ...twitchBroadcaster,
+  ...twitchUser,
+  ...avatarUrl,
+  chatter_user_id: str,
+  chatter_user_login: str,
+  chatter_user_name: str,
+  chatter_is_anonymous: bool,
+  color: str,
+  badges: z3.array(twitchBadge),
+  message: z3.looseObject({ text: str, fragments: z3.array(z3.unknown()) }),
+  message_id: str,
+  notice_type: str,
+  system_message: str,
+  /** Emotes of `message`, normalised like chat-message emotes (ZAF-1306). */
+  emotes: z3.array(z3.unknown()).optional()
+};
+var twitchImage = z3.looseObject({ url_1x: str, url_2x: str, url_4x: str });
+var twitchEnabledValue = z3.looseObject({ is_enabled: bool, value: num });
+var twitchRewardDefinition = z3.looseObject({
+  ...twitchBroadcaster,
+  id: str,
+  title: str,
+  cost: num,
+  prompt: str,
+  background_color: str,
+  is_enabled: bool,
+  is_paused: bool,
+  is_in_stock: bool,
+  is_user_input_required: bool,
+  should_redemptions_skip_request_queue: bool,
+  max_per_stream: twitchEnabledValue,
+  max_per_user_per_stream: twitchEnabledValue,
+  global_cooldown: z3.looseObject({ is_enabled: bool, seconds: num }),
+  image: twitchImage.nullable(),
+  default_image: twitchImage,
+  cooldown_expires_at: nullableStr,
+  redemptions_redeemed_current_stream: num.nullable()
+});
+var twitchRedemption = z3.looseObject({
+  ...twitchBroadcaster,
+  ...twitchUser,
+  ...avatarUrl,
+  id: str,
+  user_input: str,
+  status: str,
+  redeemed_at: str,
+  reward: z3.looseObject({ id: str, title: str, cost: num, prompt: str })
+});
+var twitchPollVoting = z3.looseObject({ is_enabled: bool, amount_per_vote: num });
+var twitchPollBase = {
+  ...twitchBroadcaster,
+  id: str,
+  title: str,
+  choices: z3.array(
+    z3.looseObject({
+      id: str,
+      title: str,
+      votes: num.optional(),
+      bits_votes: num.optional(),
+      channel_points_votes: num.optional()
+    })
+  ),
+  bits_voting: twitchPollVoting,
+  channel_points_voting: twitchPollVoting,
+  started_at: str
+};
+var twitchPredictionOutcome = z3.looseObject({
+  id: str,
+  title: str,
+  color: str,
+  users: num.optional(),
+  channel_points: num.optional(),
+  top_predictors: z3.array(
+    z3.looseObject({
+      ...twitchUser,
+      channel_points_used: num,
+      channel_points_won: num.nullable()
+    })
+  ).nullable().optional()
+});
+var twitchPredictionBase = {
+  ...twitchBroadcaster,
+  id: str,
+  title: str,
+  outcomes: z3.array(twitchPredictionOutcome),
+  started_at: str
+};
+var twitchGoalBase = {
+  ...twitchBroadcaster,
+  id: str,
+  type: str,
+  description: str,
+  current_amount: num,
+  target_amount: num,
+  started_at: str
+};
+var twitchHypeTrainBase = {
+  ...twitchBroadcaster,
+  id: str,
+  type: str,
+  level: num,
+  total: num,
+  top_contributions: z3.array(
+    z3.looseObject({ ...twitchUser, type: str, total: num })
+  ),
+  started_at: str,
+  is_shared_train: bool,
+  shared_train_participants: z3.array(z3.unknown()).nullable()
+};
+var moderationLogEntry = z3.looseObject({
+  action: str,
+  platform: str,
+  target_user_id: nullableStr,
+  target_username: nullableStr,
+  target_display_name: nullableStr,
+  moderator_name: str,
+  moderator_login: nullableStr,
+  reason: nullableStr,
+  duration_secs: num.nullable(),
+  ends_at: nullableStr,
+  target_message_id: nullableStr,
+  created_at: str
+});
+var chatMessagePayloadSchema = z3.looseObject({
+  account_id: str,
+  platform: str,
+  channel_name: nullableStr,
+  user_id: nullableStr,
+  username: str,
+  display_name: nullableStr,
+  avatar_url: nullableStr,
+  message: str,
+  /** Platform-specific emote entries. */
+  emotes: z3.array(z3.unknown()).nullable(),
+  /** Twitch GIF fragments `{ id, url, provider, alt }`; absent without a GIF. */
+  gifs: z3.array(z3.unknown()).optional(),
+  /** Platform-specific badge entries. */
+  badges: z3.array(z3.unknown()).nullable(),
+  color: nullableStr,
+  is_mod: bool,
+  is_sub: bool,
+  is_vip: bool,
+  sub_tier: nullableStr,
+  platform_message_id: nullableStr,
+  lumio_user_id: nullableStr,
+  reply_parent_msg_id: nullableStr,
+  reply_parent_username: nullableStr,
+  reply_parent_login: nullableStr,
+  reply_parent_message: nullableStr,
+  created_at: nullableStr,
+  message_type: nullableStr,
+  user_treatment: nullableStr,
+  live_chat_id: str.optional(),
+  is_shared_chat: bool.optional(),
+  source_channel: z3.unknown().optional(),
+  announcement_color: z3.unknown().optional()
+});
+var kickUser = z3.looseObject({
+  user_id: num,
+  username: str,
+  channel_slug: str,
+  is_verified: bool,
+  profile_picture: str,
+  is_anonymous: bool.optional(),
+  identity: z3.unknown().optional()
+});
+var kickCanonicalUser = {
+  user_id: str,
+  user_login: str,
+  user_name: str,
+  is_anonymous: bool
+};
+var kickSubscription = z3.looseObject({
+  ...kickCanonicalUser,
+  ...avatarUrl,
+  broadcaster: kickUser,
+  subscriber: kickUser,
+  duration: num,
+  cumulative_months: num,
+  created_at: str,
+  expires_at: str
+});
+var kickRedemption = z3.looseObject({
+  ...kickCanonicalUser,
+  broadcaster: kickUser,
+  redeemer: kickUser,
+  id: str,
+  user_input: str,
+  status: str,
+  redeemed_at: str,
+  reward: z3.looseObject({ id: str, title: str, cost: num })
+});
+var spotifySource = {
+  source: str.optional(),
+  extension_id: str.optional(),
+  install_id: str.optional()
+};
+var spotifyTrackInfo = {
+  action: str,
+  track_id: str,
+  track_name: str,
+  artist: str,
+  album: str,
+  album_art: str,
+  song_url: str
+};
+var youtubeAuthor = {
+  user_id: str,
+  user_login: str,
+  displayName: str,
+  avatarUrl: str
+};
+var LUMIO_EVENT_PAYLOAD_SCHEMAS = {
+  // Twitch
+  "twitch:follower": z3.looseObject({
+    ...twitchBroadcaster,
+    ...twitchUser,
+    ...avatarUrl,
+    followed_at: str
+  }),
+  "twitch:subscribe": z3.looseObject({
+    ...twitchChatNotice,
+    tier: str,
+    duration_months: num,
+    is_prime: bool.optional(),
+    sub: z3.looseObject({ sub_tier: str, is_prime: bool, duration_months: num })
+  }),
+  "twitch:gift": z3.looseObject({
+    ...twitchChatNotice,
+    /** Sub tier (`1000`, `2000`, `3000`). */
+    tier: str.optional(),
+    duration_months: num.optional(),
+    /** Gifts in a community gift (`community_sub_gift`). */
+    total: num.optional(),
+    /** The gifter's all-time gift count; `null` when anonymous. */
+    cumulative_total: num.nullable().optional(),
+    community_gift_id: nullableStr.optional(),
+    /** Set for a single gift (`sub_gift`), absent for a community gift. */
+    recipient_user_id: str.optional(),
+    recipient_user_login: str.optional(),
+    recipient_user_name: str.optional()
+  }),
+  "twitch:resub": z3.looseObject({
+    ...twitchChatNotice,
+    cumulative_months: num,
+    duration_months: num,
+    streak_months: num.nullable(),
+    is_gift: bool,
+    tier: str.optional(),
+    is_prime: bool.optional(),
+    gifter_is_anonymous: bool.nullable(),
+    gifter_user_login: nullableStr,
+    gifter_user_name: nullableStr,
+    resub: z3.looseObject({
+      cumulative_months: num,
+      duration_months: num,
+      streak_months: num.nullable(),
+      sub_plan: str,
+      is_gift: bool
+    })
+  }),
+  "twitch:cheer": z3.looseObject({
+    ...twitchBroadcaster,
+    ...avatarUrl,
+    user_id: nullableStr,
+    user_login: nullableStr,
+    user_name: nullableStr,
+    is_anonymous: bool,
+    bits: num,
+    message: str,
+    /** Cheermote entries for the cheer words in `message` (`kind: "cheermote"`). */
+    emotes: z3.array(z3.unknown()).optional(),
+    /** The cheermote for the total, when the channel's cheermotes loaded. */
+    cheermote: z3.unknown().optional()
+  }),
+  "twitch:raid": z3.looseObject({
+    from_broadcaster_user_id: str,
+    from_broadcaster_user_login: str,
+    from_broadcaster_user_name: str,
+    to_broadcaster_user_id: str,
+    to_broadcaster_user_login: str,
+    to_broadcaster_user_name: str,
+    viewers: num,
+    ...avatarUrl,
+    displayName: str.optional(),
+    /** The raider's channel info from Helix, when it loaded. */
+    title: str.optional(),
+    category: str.optional()
+  }),
+  "twitch:reward": twitchRedemption,
+  "twitch:reward_status": twitchRedemption,
+  "twitch:reward_add": twitchRewardDefinition,
+  "twitch:reward_update": twitchRewardDefinition,
+  "twitch:reward_remove": twitchRewardDefinition,
+  "twitch:hype_train": z3.looseObject({
+    ...twitchHypeTrainBase,
+    progress: num,
+    goal: num,
+    expires_at: str,
+    all_time_high_level: num.optional(),
+    all_time_high_total: num.optional()
+  }),
+  "twitch:hype_train_end": z3.looseObject({
+    ...twitchHypeTrainBase,
+    ended_at: str,
+    cooldown_ends_at: str
+  }),
+  "twitch:poll": z3.looseObject({ ...twitchPollBase, ends_at: str }),
+  "twitch:poll_end": z3.looseObject({
+    ...twitchPollBase,
+    status: str,
+    ended_at: str
+  }),
+  "twitch:prediction": z3.looseObject({ ...twitchPredictionBase, locks_at: str }),
+  "twitch:prediction_lock": z3.looseObject({
+    ...twitchPredictionBase,
+    locked_at: str
+  }),
+  "twitch:prediction_end": z3.looseObject({
+    ...twitchPredictionBase,
+    status: str,
+    ended_at: str,
+    winning_outcome_id: nullableStr
+  }),
+  "twitch:goal": z3.looseObject(twitchGoalBase),
+  "twitch:goal_end": z3.looseObject({
+    ...twitchGoalBase,
+    ended_at: str,
+    is_achieved: bool
+  }),
+  "twitch:ad_break": z3.looseObject({
+    ...twitchBroadcaster,
+    requester_user_id: str,
+    requester_user_login: str,
+    requester_user_name: str,
+    /** Seconds; Twitch's own sample payload sends it as a string. */
+    duration_seconds: z3.union([num, str]),
+    /** Twitch's own sample payload sends it as a string. */
+    is_automatic: z3.union([bool, str]),
+    started_at: str
+  }),
+  "twitch:ban": moderationLogEntry,
+  "twitch:unban": moderationLogEntry,
+  "twitch:stream_online": z3.looseObject({
+    ...twitchBroadcaster,
+    id: str,
+    type: str,
+    started_at: str,
+    /** Channel info from Helix, when it loaded. */
+    title: str.optional(),
+    category: str.optional()
+  }),
+  "twitch:stream_offline": z3.looseObject({
+    ...twitchBroadcaster,
+    /** Set when the stream's start is known. */
+    started_at: str.optional(),
+    duration_seconds: num.optional()
+  }),
+  "twitch:stream_update": z3.looseObject({
+    ...twitchBroadcaster,
+    title: str,
+    language: str,
+    category_id: str,
+    category_name: str,
+    content_classification_labels: z3.array(str),
+    tags: z3.array(str).optional(),
+    /** Diff against the previous channel info, when it was known. */
+    title_changed: bool.optional(),
+    category_changed: bool.optional(),
+    language_changed: bool.optional(),
+    tags_changed: bool.optional(),
+    old_title: str.optional(),
+    old_category_name: str.optional(),
+    old_tags: z3.array(str).optional()
+  }),
+  // YouTube
+  "youtube:subscribe": z3.looseObject({
+    channel_id: str,
+    video_id: str,
+    title: str,
+    published: str,
+    updated: str
+  }),
+  "youtube:member": z3.looseObject({
+    ...youtubeAuthor,
+    membership_event_type: str,
+    memberLevelName: nullableStr,
+    memberMonth: num.nullable(),
+    isUpgrade: bool,
+    display_message: str,
+    userComment: str
+  }),
+  "youtube:superchat": z3.looseObject({
+    ...youtubeAuthor,
+    amountMicros: num,
+    amountDisplayString: str,
+    currency: str,
+    tier: num,
+    userComment: str,
+    headerBackgroundColor: num,
+    bodyBackgroundColor: num
+  }),
+  "youtube:supersticker": z3.looseObject({
+    ...youtubeAuthor,
+    amountMicros: num,
+    amountDisplayString: str,
+    currency: str,
+    stickerName: str,
+    stickerUrl: str
+  }),
+  "youtube:gift_membership": z3.looseObject({
+    ...youtubeAuthor,
+    giftCount: num,
+    isGift: bool,
+    gift_memberships_level_name: nullableStr
+  }),
+  /** Stored in the event history only; never broadcast live (no fixture). */
+  "youtube:gift_membership_received": z3.looseObject({
+    user_id: nullableStr,
+    user_login: nullableStr,
+    displayName: str,
+    avatarUrl: nullableStr,
+    gifter_channel_id: nullableStr,
+    gifter_display_name: nullableStr,
+    gift_memberships_level_name: nullableStr
+  }),
+  "youtube:poll": z3.looseObject({
+    poll_id: str,
+    question: str,
+    status: str,
+    options: z3.array(
+      z3.looseObject({
+        option_text: str,
+        tally: nullableStr,
+        vote_ratio: num.nullable()
+      })
+    )
+  }),
+  "youtube:stream_online": z3.looseObject({
+    broadcast_id: str,
+    started_at: str,
+    title: str.optional(),
+    category: str.optional()
+  }),
+  "youtube:stream_offline": z3.looseObject({
+    broadcast_id: str,
+    started_at: str.optional(),
+    duration_seconds: num.optional()
+  }),
+  // Kick
+  "kick:follower": z3.looseObject({
+    ...kickCanonicalUser,
+    ...avatarUrl,
+    broadcaster: kickUser,
+    follower: kickUser
+  }),
+  "kick:subscribe": kickSubscription,
+  "kick:resub": kickSubscription,
+  "kick:gift": z3.looseObject({
+    ...kickCanonicalUser,
+    ...avatarUrl,
+    broadcaster: kickUser,
+    gifter: kickUser,
+    giftees: z3.array(kickUser),
+    /** Usernames of `giftees`. */
+    giftRecipients: z3.array(str),
+    giftCount: num,
+    total: num,
+    isGift: bool,
+    is_gift: bool,
+    /** The first giftee. */
+    recipient_user_id: str.optional(),
+    recipient_user_login: str.optional(),
+    recipient_user_name: str.optional(),
+    created_at: str,
+    expires_at: str
+  }),
+  "kick:kicks": z3.looseObject({
+    ...kickCanonicalUser,
+    ...avatarUrl,
+    broadcaster: kickUser,
+    sender: kickUser,
+    gift: z3.looseObject({
+      amount: num,
+      name: str,
+      type: str,
+      tier: str,
+      message: str,
+      pinned_time_seconds: num
+    }),
+    kicks: num,
+    message: str,
+    kick_gift_id: str,
+    kick_gift_name: str,
+    kick_gift_type: str,
+    kick_gift_tier: str,
+    kick_gift_color: str,
+    kick_gift_image: z3.looseObject({ static: str, animated: str }),
+    kick_pinned_time_seconds: num,
+    created_at: str
+  }),
+  "kick:reward": kickRedemption,
+  "kick:reward_status": kickRedemption,
+  "kick:stream_online": z3.looseObject({
+    broadcaster: kickUser,
+    is_live: bool,
+    title: str,
+    started_at: str,
+    ended_at: nullableStr
+  }),
+  "kick:stream_offline": z3.looseObject({
+    broadcaster: kickUser,
+    is_live: bool,
+    title: str,
+    started_at: str,
+    ended_at: str,
+    duration_seconds: num.optional()
+  }),
+  "kick:stream_update": z3.looseObject({
+    broadcaster: kickUser,
+    metadata: z3.looseObject({
+      title: str,
+      language: str,
+      has_mature_content: bool,
+      category: z3.looseObject({ id: num, name: str, thumbnail: str })
+    }),
+    title: str,
+    language: str,
+    has_mature_content: bool,
+    category_id: str,
+    category_name: str,
+    /** Diff against the previous stream info, when it was known. */
+    title_changed: bool.optional(),
+    category_changed: bool.optional(),
+    language_changed: bool.optional(),
+    old_title: str.optional()
+  }),
+  // Spotify
+  "spotify:track": z3.looseObject({
+    is_playing: bool,
+    progress_ms: num,
+    timestamp: num,
+    shuffle: str,
+    repeat: str,
+    track: z3.looseObject({
+      id: str,
+      uri: str,
+      name: str,
+      artist: str,
+      album: str,
+      album_art: str,
+      duration_ms: num
+    }),
+    device: z3.looseObject({
+      id: str,
+      name: str,
+      device_type: str,
+      is_active: bool,
+      volume_percent: num.nullable()
+    }).nullable(),
+    context: z3.looseObject({ context_type: str, id: str, name: nullableStr, uri: str }).nullable(),
+    /** The Lumio user whose action caused the change; `null` when it came from Spotify. */
+    triggered_by: nullableStr.optional()
+  }),
+  "spotify:play": z3.looseObject({
+    ...spotifyTrackInfo,
+    ...spotifySource,
+    track_uri: str
+  }),
+  "spotify:pause": z3.looseObject({ ...spotifyTrackInfo, ...spotifySource }),
+  "spotify:skip": z3.looseObject({ action: str, ...spotifySource }),
+  "spotify:volume": z3.looseObject({
+    ...spotifyTrackInfo,
+    ...spotifySource,
+    oldVolume: num,
+    newVolume: num,
+    volume_percent: num
+  }),
+  "spotify:queue_add": z3.looseObject({ uri: str, ...spotifySource }),
+  "spotify:device": z3.looseObject({
+    fromDevice: str,
+    fromDeviceType: str,
+    toDevice: str,
+    toDeviceType: str
+  }),
+  "spotify:playlist_add": z3.looseObject({ playlistId: str }),
+  "spotify:playlist_remove": z3.looseObject({ playlistId: str, trackUri: str }),
+  "spotify:playlist_create": z3.looseObject({ playlistName: str }),
+  "spotify:playlist_edit": z3.looseObject({ playlistName: str }),
+  "spotify:playlist_delete": z3.looseObject({ playlistId: str }),
+  // StreamElements
+  "streamelements:tip": z3.looseObject({
+    _id: str,
+    channel: str,
+    provider: str,
+    type: str,
+    flagged: bool,
+    createdAt: str,
+    updatedAt: str,
+    data: z3.looseObject({
+      tipId: str,
+      username: str,
+      displayName: str,
+      providerId: str.optional(),
+      amount: num,
+      currency: str,
+      message: str,
+      avatar: str.optional()
+    })
+  }),
+  // Chat
+  "twitch:chat": chatMessagePayloadSchema,
+  "youtube:chat": chatMessagePayloadSchema,
+  "kick:chat": chatMessagePayloadSchema,
+  "chat:message": chatMessagePayloadSchema
+};
+function lumioEventPayloadSchema(type) {
+  return LUMIO_EVENT_PAYLOAD_SCHEMAS[type];
+}
+function parseLumioEventPayload(type, data) {
+  return LUMIO_EVENT_PAYLOAD_SCHEMAS[type].safeParse(data);
+}
+
 // src/components.ts
 var LUMIO_COMPONENT_TYPES = [
   "Box",
@@ -257,6 +906,34 @@ var LUMIO_COMPONENT_TYPES = [
   "EditorFontPicker",
   "EditorChannelRow"
 ];
+var ACTION_EXECUTE_ERRORS = {
+  /** Malformed request: `action` is not a string or `params` is not an object. */
+  INVALID_REQUEST: -32602,
+  /** This host cannot run actions (no install, or a credential that may not run them). */
+  UNAVAILABLE: -32001,
+  /** The extension does not declare the action's permission, or the caller may not use it. */
+  DENIED: -32002,
+  /** The API does not dispatch this action. */
+  UNKNOWN_ACTION: -32003,
+  /** The API rejected the action's params. */
+  INVALID_PARAMS: -32004,
+  /** The action ran and failed (e.g. its target service is not connected). */
+  FAILED: -32005
+};
+var SERVER_FUNCTION_ERRORS = {
+  /** Malformed request: `fn` is not a function name or `params` is not an object. */
+  INVALID_REQUEST: -32602,
+  /** This host cannot call server functions (no install, or a credential that may not call them). */
+  UNAVAILABLE: -32001,
+  /** The caller may not run the function (an `editorOnly` function outside the editor, or missing permission). */
+  DENIED: -32002,
+  /** The install's published version has no server function with this name, or not of this kind. */
+  UNKNOWN_FUNCTION: -32003,
+  /** The API rejected the params (missing or mistyped `arg()` value, invalid row id or column value). */
+  INVALID_PARAMS: -32004,
+  /** The function ran and failed (rate limit, no data schema, storage quota, timeout). */
+  FAILED: -32005
+};
 var WORKER_METHODS = {
   UI_RENDER: "ui.render",
   UI_READY: "ui.ready",
@@ -269,7 +946,8 @@ var WORKER_METHODS = {
   UI_ACTION: "ui.action",
   SOUND_PLAY: "sound.play",
   SOUND_STOP: "sound.stop",
-  SOUND_LIST: "sound.list"
+  SOUND_LIST: "sound.list",
+  ACTION_EXECUTE: "action.execute"
 };
 var HOST_METHODS = {
   LIFECYCLE_INIT: "lifecycle.init",
@@ -278,18 +956,39 @@ var HOST_METHODS = {
   EVENT_PLATFORM: "event.platform",
   STORAGE_UPDATE: "storage.update",
   THEME_CHANGE: "theme.change",
-  CONFIG_UPDATE: "config.update"
+  CONFIG_UPDATE: "config.update",
+  SERVER_REALTIME: "server.realtime"
+};
+var REALTIME_LIMITS = {
+  /** 1–64 characters of `A-Z a-z 0-9 _ . : -`, starting with a letter or digit. */
+  TOPIC_PATTERN: /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,63}$/,
+  /** Largest serialized payload of one push, in bytes. */
+  MAX_PAYLOAD_BYTES: 16 * 1024,
+  /** Most pushes one handler run may make. */
+  MAX_PUSHES_PER_INVOCATION: 32,
+  /** Pushes per install and minute; pushes over the cap are dropped. */
+  MAX_PUSHES_PER_MINUTE: 300,
+  /**
+   * Published bytes (serialized `{ topic, payload }`) per install and minute;
+   * pushes over the cap are dropped.
+   */
+  MAX_BYTES_PER_MINUTE: 1024 * 1024
 };
 export {
+  ACTION_EXECUTE_ERRORS,
   ACTION_TYPES,
   EXTENSION_RUNTIME_LABEL_PLACEHOLDER,
   HOST_METHODS,
   LUMIO_COMPONENT_TYPES,
+  LUMIO_EVENT_PAYLOAD_SCHEMAS,
   LUMIO_EVENT_TYPES,
   MESSAGE_TYPES,
+  REALTIME_LIMITS,
+  SERVER_FUNCTION_ERRORS,
   STORAGE_SCOPES,
   WORKER_METHODS,
   actionMessageSchema,
+  chatMessagePayloadSchema,
   configUpdateMessageSchema,
   errorMessageSchema,
   eventMessageSchema,
@@ -300,10 +999,12 @@ export {
   initMessageSchema,
   isValidExtensionRuntimeOriginTemplate,
   lumioActionTypeSchema,
+  lumioEventPayloadSchema,
   lumioEventTypeSchema,
   lumioMessageSchema,
   nodeConfigRequestMessageSchema,
   nodeConfigUpdateMessageSchema,
+  parseLumioEventPayload,
   readyMessageSchema,
   storageScopeSchema,
   storageUpdateMessageSchema,