Guild-Only Scope

FullEvent::Message { new_message: msg, .. } => {
    let payload = EventMessage::from(msg);
    let guild_id = msg.guild_id.map(|guild| guild.get().to_string());
    if guild_id.is_none() {
        return; // Drop event
    }
    // ...
}

// This will NEVER fire for DMs
on('messageCreate', async (msg) => {
  await msg.reply('Hello!') // Only works in guild channels
})

slash({
  name: 'ping',
  description: 'Pong!',
  handler: async (interaction) => {
    // Only available in the guild where this script is deployed
    await interaction.reply({ content: 'Pong!' })
  }
})

// apps/runtime/src/runtime/mod.rs:90-102
pub async fn deploy_guild_script(&self, deployment: Deployment) -> Result<(), AnyError> {
    let worker_idx = {
        let mut routes = self.guild_routes.lock();
        match routes.get(&deployment.guild_id).copied() {
            Some(worker_idx) => worker_idx,
            None => {
                let worker_idx = self.default_worker_for_guild(&deployment.guild_id);
                routes.insert(deployment.guild_id.clone(), worker_idx);
                worker_idx
            }
        }
    };
    // ...
}

// Keys are automatically scoped to the guild
await kv.set('config', { prefix: '!' })

// Different guilds have independent key spaces
// Guild A's 'config' key is separate from Guild B's 'config' key

slash({
  name: 'ban',
  description: 'Ban a user',
  handler: async (interaction) => {
    // Discord's permission checks work naturally
    // because the command is guild-scoped
  }
})

# View logs for a specific guild
flora logs --guild 123456789

# All events, ops, and errors include guild context

// Not in flora - separate bot
client.on('messageCreate', async (msg) => {
  if (msg.channel.type === 'DM') {
    // Forward to modmail channel in a guild
    const channel = await client.channels.fetch('CHANNEL_ID')
    await channel.send(`DM from ${msg.author.tag}: ${msg.content}`)
  }
})

slash({
  name: 'private',
  description: 'Private response',
  handler: async (interaction) => {
    // Only the user who triggered the interaction can see this
    await interaction.reply({
      content: 'This is private!',
      flags: MessageFlags.Ephemeral
    })
  }
})

#[expose_payload]
pub struct EventMessage {
    id: String,
    channel_id: String,
    guild_id: Option<String>, // Always Some() for flora events
    content: String,
    author: EventUser,
    member: Option<EventMember>,
}

#[op2(async)]
pub async fn op_kv_get(
    state: Rc<RefCell<OpState>>,
    #[string] key: String,
) -> Result<Option<serde_json::Value>, JsErrorBox> {
    let guild_id = {
        let state = state.borrow();
        state.borrow::<String>().clone() // Guild ID
    };
    // KV operations are scoped to this guild
}

pub enum SecretScope {
    Runtime,        // Shared across all guilds
    Guild(String),  // Scoped to a specific guild
}