simcord 2.2.0__tar.gz → 2.3.0__tar.gz

{simcord-2.2.0 → simcord-2.3.0}/CHANGELOG.md

@@ -4,6 +4,30 @@ This changelog is generated with [towncrier](https://towncrier.readthedocs.io/).
 
 <!-- towncrier release notes start -->
 
+## 2.3.0 (2026-10-05)
+
+### Features
+
+- Add the temporary `future_behavior=False` migration bridge in SimCord 2.3. Opt in with `simcord.run(bot, future_behavior=True)` or the pytest marker to acknowledge only the current error prefix and detach nested mutable result observations. Legacy live error lists, lifetime acknowledgement and payload aliasing remain the defaults, with targeted deprecation warnings. SimCord 3.0 removes the flag and makes the opt-in semantics the defaults. Startup/restart READY and restart guild-replay settlement retain their independent five-second budgets.
+
+### Bug fixes
+
+- Describe all seven existing protocol-2 preview actions in the packaged schema, including required targets/controls and envelope fields. Preserve focus defaults, unknown metadata, multipart modal uploads, and runtime authorization/replay checks. Reuse the existing builder operation guard for actors without changing ownership or permissions.
+- Share message validation across HTTP, actors and backend creation/editing: enforce the 10-embed count, combined 6000-character limit and individual embed text/field limits, excluding surrounding whitespace without changing stored text. Reject empty new user/bot messages while retaining attachment-, embed-, component- and poll-only sends, nullable/partial edits and empty interaction deferrals. Previously accepted invalid messages now fail with code 50035, and invalid interaction responses do not consume acknowledgement.
+  Interaction update callbacks without a source message now fail before acknowledgement instead of silently succeeding.
+
+  Prepare forum starter fields, components and every upload read before creating thread/message/CDN state, then publish the existing ordered events only after thread, starter and parent state are complete. Validation or upload-read failures no longer leave orphan posts or gateway events. Preparation consumes upload streams; an earlier successfully read stream must be rewound or replaced if a later read fails. Subscriber exceptions after publication begins are outside this atomicity boundary.
+  Starter reference identifiers are also validated before publication, preventing malformed references from corrupting the forum's previous last-post pointer.
+- Recognize shielded Discord waits on Python 3.14.8 without treating the caller captured by asyncio's cancellation cleanup as an additional dependency.
+
+
+## 2.2.1 (2026-09-24)
+
+### Bug fixes
+
+- Fixed View/Modal expiry recognition for views that never reach the store's dispatch tables — a view whose dispatchable items are all `DynamicItem`s (e.g. a `LayoutView` built only from patterned custom IDs) registered a live expiry task that settlement never recognized, so its `timeout=` blocked actor operations and fired on the wall clock. Expiry tasks are now identified by the coroutine they run (`BaseView.__timeout_task_impl`), which covers every registered view regardless of how the store indexes it.
+
+
 ## 2.2.0 (2026-09-23)
 
 ### Features

{simcord-2.2.0 → simcord-2.3.0}/CONTRIBUTING.md

@@ -69,6 +69,16 @@ Maintainers update `pyproject.toml`, then consume fragments with
 version commit are tagged `vX.Y.Z`; the release workflow verifies the tag,
 quality gates, documentation, and built metadata before publishing.
 
+For the 2.3 → 3.0 migration, keep the two release lines separate and verify both
+legacy defaults and `future_behavior=True` before tagging 2.3.
+
+The expanded 3.0 preview work additionally requires authorized Discord comparisons
+with complete provenance and dated human accessibility checks. Its reference ledger
+is `tests/fixtures/preview/coverage.json`; blocked or non-comparable rows are not
+passing evidence. These preview-specific requirements do not block the compatible
+2.3 bridge, which retains the already-released protocol-2 preview without new
+visual fidelity claims.
+
 ## Reporting bugs
 
 A failing test using `simcord` is the perfect bug report. If your bot hits an

{simcord-2.2.0 → simcord-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simcord
-Version: 2.2.0
+Version: 2.3.0
 Summary: Offline discord.py bot testing with pytest. No network, token, or test server.
 Project-URL: Homepage, https://github.com/SilentHacks/simcord
 Project-URL: Documentation, https://simcord.readthedocs.io/

{simcord-2.2.0 → simcord-2.3.0}/docs/concepts.md

@@ -95,13 +95,16 @@ assert channel.last_message.content == "Pong!"   # the reply is already here
 
 Bot-owned work stays bot-owned across parking, timeout, cancellation, later actions, startup,
 and restart. Recognized waits — `Client.wait_for` (including its `timeout=`), View/Modal
-completion, store-registered View/Modal expiry timers, `discord.ext.tasks` loop intervals,
+completion, View/Modal expiry timers, `discord.ext.tasks` loop intervals,
 composed `gather`/`shield`/`wait`/`TaskGroup`, explicit `env.external_wait(...)`, and verified
 far-future sleeps — may remain. A timer whose only job is resuming a recognized wait — a
 `wait_for` deadline on a listener, a View/Modal expiry, a loop interval, a wake-up timer
 scheduled inside `external_wait` — is virtual: it fires only via `env.advance_time()` or the
 awaited input, never the wall clock. Verified far-future sleeps keep their real fallback, and
 a View sent with no dispatchable items never registers (its expiry keeps real-time behavior).
+Views whose dispatchable items are all `DynamicItem`s are covered too — expiry is identified
+from the task's coroutine, not the store's dispatch table; `view.wait()` on such a view is not
+recognized, so `await env.external_wait(view.wait(), reason="...")` if a bot awaits one.
 Unknown waits remain active and time out. Use a reasoned, scoped declaration for external
 input:
 

{simcord-2.2.0 → simcord-2.3.0}/docs/guides/diagnostics.md

@@ -27,10 +27,17 @@ excluded — a non-command message isn't a bug.)
 ### Errors fail tests by default
 
 !!! warning "Uninspected errors are re-raised at teardown"
-    If the bot raised errors during a test and the test never inspected them, `simcord.run`
-    re-raises them as an `ExceptionGroup` when the environment closes — so a swallowed bug
-    can't slip past a green test. **Reading `env.errors` counts as inspecting**: your
-    assertions take over from there.
+    With the 2.x default, reading `env.errors` acknowledges errors for the environment's
+    entire lifetime, including errors that arrive later. A saved list stays live.
+    SimCord 2.3 warns on this legacy read. Use `simcord.run(bot, future_behavior=True)`
+    to adopt the intended 3.0 behavior now: each read returns a shallow list snapshot and
+    acknowledges only the errors captured so far. A later error still fails teardown,
+    including one captured during shutdown; previously acknowledged errors are not
+    re-raised alongside it. Exception objects and their tracebacks are preserved.
+
+The `future_behavior` flag defaults to `False` in 2.3. SimCord 3.0 removes the flag and
+makes snapshot/prefix acknowledgement the default. Saving an empty opt-in snapshot does
+not acknowledge errors that arrive later, and mutating a snapshot cannot change the history.
 
 You have three ways to handle this:
 
@@ -46,9 +53,14 @@ async with simcord.run(bot, check_errors=False) as env:
     ...
 ```
 
-`env.raise_errors()` is the one-call way to assert "the bot ran cleanly": it raises an
-`ExceptionGroup` of everything captured (even a single error) and does nothing if there were
-none.
+`env.raise_errors()` always raises an `ExceptionGroup` of the **entire captured history**
+(even errors acknowledged earlier), or does nothing if there were none. It acknowledges
+only the current prefix in opt-in mode, including an empty prefix; later errors still fail
+teardown. `check_errors=False` disables automatic checking in either mode. Teardown never
+masks an exception already propagating from the test body.
+
+`env.error_cursor` and `env.errors_since(cursor)` are non-consuming observations used by
+Preview diagnostics. They do not acknowledge errors or disable teardown checking.
 
 ## Assertions
 
@@ -89,8 +101,8 @@ assert_error(env, discord.Forbidden, code=50013)   # matches the wrapped origina
 assert_no_errors(env)                               # the symmetric "ran cleanly" check
 ```
 
-`assert_error` reads `env.errors`, which counts as inspecting them (see below), so it also
-satisfies the teardown guard.
+`assert_error` reads `env.errors`, so it acknowledges the same errors as a direct read:
+the whole lifetime by default, or only the current prefix with `future_behavior=True`.
 
 ## The transcript
 
@@ -162,8 +174,15 @@ simcord_env.inject_error("PUT", "/guilds/*/bans/*", status=403, code=50013, time
 
 Because failures surface as genuine `discord.Forbidden` / `discord.HTTPException` with real
 codes, your `except discord.HTTPException:` branches are exercised exactly as in production.
+
 ## Settlement timeouts and recovery
 
+`settle_timeout` defaults to five seconds for actor operations, `env.settle()`, and the
+pre-restart drain; `env.settle(timeout=...)` overrides that individual settle. Startup
+READY settlement has its own fixed five-second budget, independent of `settle_timeout`.
+Restart uses a fresh fixed five-second READY budget and then a separate fixed five-second
+guild-replay budget. These are settlement budgets, not a timeout on `setup_hook` or login.
+
 `TimeoutError` reports the operation, effective timeout, bot-owned task or callback, wait
 reason, and any recognized waits left parked. A timeout or cancellation does not release
 ownership or pretend work completed; state may already have changed. Release the real

{simcord-2.2.0 → simcord-2.3.0}/docs/guides/fixtures.md

@@ -96,9 +96,17 @@ Both `simcord.run(bot, **options)` and the underlying `Env` accept these keyword
 | --- | --- | --- |
 | `strict_sync` | `True` | Unsynced app commands can't be invoked — invoking one fails the test, catching forgotten `tree.sync()` calls. Set `False` to auto-register unsynced commands for isolated unit tests. |
 | `check_errors` | `True` | At teardown, errors the bot raised but the test never inspected are re-raised as an `ExceptionGroup`, so bot bugs can't pass silently. Set `False` to opt out. |
+| `future_behavior` | `False` | Temporary 2.3 bridge: shallow error snapshots with prefix acknowledgement, and detached mutable result payload snapshots. Must be a bool. In 3.0 the flag is removed and these semantics become the defaults. |
 | `approved_intents` | all | Simulates developer-portal privileged-intent toggles. |
 | `shard_count` | client setting | Supplies the Get Gateway Bot recommendation when an `AutoShardedClient` does not configure `shard_count` itself. |
 | `settle_timeout` | `5.0` seconds | Default maximum time for joining runnable bot work; a direct settle `timeout=` overrides it. |
+
+`settle_timeout` does not change startup's fixed five-second READY settlement budget.
+Restart drains existing work using `settle_timeout`, then gets a fresh fixed five-second
+READY budget and a separate fixed five-second guild-replay budget. These budgets do not
+bound login or `setup_hook`. `strict_sync=False` remains an independent opt-out; the
+migration bridge does not change command registration.
+
 External waits must be scoped with `await env.external_wait(awaitable, reason="...")`; unknown waits time out. Overlapping actor, builder, lifecycle, and time-control operations reject before mutation. Teardown cancels bot-owned work but leaves caller-owned tasks alive.
 
 ```python
@@ -161,6 +169,12 @@ async def test_command_logic_in_isolation(simcord_env):
     ...
 ```
 
+To opt into the 3.0 observation behavior for a plugin fixture, use
+`@pytest.mark.simcord(future_behavior=True)`. The same flag works in a wrapper fixture
+with `simcord.run(bot, future_behavior=True)`. Legacy `env.errors` and mutable result
+payload reads emit `DeprecationWarning` with this migration guidance; startup and scalar
+result reads do not.
+
 For an override shared by many tests, drive `simcord.run` yourself in a small wrapper fixture
 instead:
 

{simcord-2.2.0 → simcord-2.3.0}/docs/guides/interactions.md

@@ -63,6 +63,26 @@ assert result.ephemeral
 assert result.response.content == f"Banned {target.mention}: spam"
 ```
 
+### The 2.3 migration bridge
+
+Use `simcord.run(bot, future_behavior=True)` (or
+`@pytest.mark.simcord(future_behavior=True)`) for the intended 3.0 observation semantics.
+Results remain **live handles**: reading them again reflects later original-response edits
+and followups. Each mutable payload read returns a detached nested snapshot, including
+components, embeds, full message payloads, modal payloads and autocomplete choices.
+Editing a returned snapshot does not edit Discord state, and subsequent backend changes
+do not rewrite a previously returned snapshot. Lists and dictionaries keep their shapes;
+absent modal/autocomplete payloads remain `None`, and empty choices remain `[]`.
+
+Modal submission always uses the backend's canonical modal, not edits to a detached
+`result.modal` snapshot. Make real changes through bot response/edit/followup APIs.
+
+The flag defaults to `False` in 2.3: existing nested payload aliasing is preserved, with a
+`DeprecationWarning` on mutable payload reads. Scalar reads such as `content`,
+`acknowledged` and `ephemeral` do not warn. In 3.0 the flag is removed and detached
+observations become the default. See [Errors & diagnostics](diagnostics.md) for the
+matching error-acknowledgement transition.
+
 ## The interaction lifecycle is real
 
 The full lifecycle behaves as on Discord:

{simcord-2.2.0 → simcord-2.3.0}/docs/guides/messages.md

@@ -121,9 +121,16 @@ Full treatment in [Errors & diagnostics](diagnostics.md).
 
 ## Validation limits
 
-Real Discord limits are enforced with real error codes. Message content over 2000
-characters, or embeds totalling over 6000 characters, raise `discord.HTTPException` with
-code `50035` — exactly as in production:
+Message creation and edits share validation across bot HTTP requests, actor helpers and
+the backend. Content is limited to 2000 characters. Messages may contain at most 10
+embeds, with at most 6000 text characters **across all embeds combined**. Individual
+embed limits are title 256, description 4096, 25 fields, field name 256, field value
+1024, footer text 2048 and author name 256. Leading and trailing whitespace in each
+embed text field is excluded from these counts; stored text is unchanged. Counts use
+Python's Unicode `len`, as in earlier 2.x releases.
+
+Invalid bot requests raise `discord.HTTPException` with code `50035`; actor/backend
+calls raise `simcord.BackendError` with the same code:
 
 ```python
 async def test_rejects_oversized(simcord_env):
@@ -133,6 +140,25 @@ async def test_rejects_oversized(simcord_env):
     assert exc.value.code == 50035
 ```
 
+Some invalid messages previously accepted by SimCord now fail, including embeds whose
+combined text exceeds 6000 characters and oversized individual embed fields. New user
+and bot messages must contain content, an attachment, an embed, components or a poll;
+content-free messages with one of those payloads remain supported. Partial edits and
+explicit `None` values can clear fields, including leaving an existing message empty.
+System messages and empty interaction deferrals are not treated as empty message sends.
+Stickers remain explicitly unsupported offline.
+Interaction message responses validate before acknowledgement; a rejected response
+can be retried. Updating an interaction's source message requires an actual source
+message (a component interaction or a modal opened from one).
+
+Forum posts prepare the entire starter message and read all uploaded files before
+creating a thread or storing CDN objects. Validation or upload-read failures leave no
+thread, starter message or gateway event behind. Subscribers to `THREAD_CREATE` and
+`MESSAGE_CREATE` see the complete thread, starter and parent state. Upload preparation
+does consume file streams: if a later upload read fails, earlier streams have already
+been read and must be rewound or replaced before retrying. This boundary does not
+include arbitrary subscriber exceptions after gateway publication begins.
+
 ## Next
 
 - [Slash commands](interactions.md) — app commands, context menus and the interaction

{simcord-2.2.0 → simcord-2.3.0}/docs/guides/preview.md

@@ -270,6 +270,15 @@ identifies the focused projection. `modal`, `candidates`, `assets`, `entities`,
 details may evolve under `protocolVersion`; assert on documented keys rather than exact payload
 layout.
 
+The packaged `protocol.schema.json` also describes protocol-2 action envelopes at
+`#/$defs/action`: `click`, `select`, `modal_submit`, `viewer`, `focus`, `refresh`,
+and `close`. Validate against that definition rather than the snapshot root.
+Unknown metadata remains accepted, and an omitted/null focus target retains its
+initial-target default. Modal values are broadly typed because controls determine
+their types; file bytes are delivered through multipart transport, not JSON.
+Schema validity does not establish authorization, freshness, control availability,
+or sequence admission: runtime checks remain authoritative.
+
 ## Screenshot profiles, modes, and reports
 
 `preview.screenshot(path, ...)` settles and pins the requested viewer/target before releasing the

{simcord-2.2.0 → simcord-2.3.0}/docs/stability.md

@@ -1,6 +1,6 @@
 ---
 title: "Stability & versioning"
-description: "What SimCord's public API covers, what stays internal, and how versioning works for the 2.0 release."
+description: "SimCord's public API, semantic versioning, and the compatible 2.3 migration bridge for 3.0."
 ---
 
 # Stability & versioning
@@ -31,9 +31,8 @@ own supervisor.
 
 SimCord follows [semantic versioning](https://semver.org/). The
 **public API** below is covered by that promise: no breaking change to it without
-a major version bump. The 2.0 release keeps this contract while changing
-settlement ownership as described above. CI continues to enforce honest parity,
-coverage, and offline-performance checks.
+a major version bump. Historical 2.0 settlement changes are described above.
+CI continues to enforce honest parity, coverage, and offline-performance checks.
 
 The fuzzer proves that across every route whose body is a field set — message
 send and edits, webhook execute, bulk delete, and the rest — an unrecognised
@@ -117,6 +116,36 @@ verified in CI, so they cannot quietly drift as discord.py evolves.
 These exception types are part of the public API precisely so your tests can
 assert on them.
 
+## Preparing for 3.0 with 2.3
+
+Use `simcord.run(bot, future_behavior=True)` (or decorate a fixture-using test with
+`@pytest.mark.simcord(future_behavior=True)`) to exercise both
+upcoming observation contracts without changing the default behavior of 2.x:
+
+- Reading `env.errors` acknowledges only the currently captured prefix and returns
+  a list snapshot. Later errors, including shutdown errors, still fail teardown.
+  Exception objects and tracebacks are preserved. Explicit `raise_errors()` checks
+  the entire history; preview diagnostics never acknowledge errors.
+- Result handles remain live, but mutable payloads are detached on each read.
+  Saved payloads no longer follow edits, and mutating them cannot change the world.
+  Read the handle again after a genuine edit or followup.
+
+Legacy error inspection and mutable result reads emit `DeprecationWarning` with
+opt-in guidance in 2.3. Enable these warnings while migrating, for example with
+`pytest -W default::DeprecationWarning`. The temporary `future_behavior` option
+will be removed in 3.0 when these semantics become unconditional. See the
+[diagnostics guide](guides/diagnostics.md) and
+[interaction guide](guides/interactions.md) for details.
+
+The compatible correctness fixes reject previously accepted invalid messages and
+prevent rejected forum requests from publishing partial state. Tests depending on
+invalid Discord payloads must change; nullable edits remain supported.
+Independent startup budgets and `strict_sync=False` remain supported.
+
+This release retains preview protocol 2. The protocol-3 work and its additional
+action kinds remain on the separate 3.0 development line. No Discord visual
+calibration or human accessibility sign-off is implied by local automated checks.
+
 ## Deprecation policy
 
 From 1.0 onward, a public-API symbol is never removed or changed incompatibly

{simcord-2.2.0 → simcord-2.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "simcord"
-version = "2.2.0"
+version = "2.3.0"
 description = "Offline discord.py bot testing with pytest. No network, token, or test server."
 readme = "README.md"
 license = "MIT"

{simcord-2.2.0 → simcord-2.3.0}/src/simcord/_dpy_internals.py

@@ -77,6 +77,13 @@ def verify() -> None:
     for suffix in ("__stopped", "__timeout_task"):
         if not any(name.endswith(suffix) for name in vars(view_probe)):  # pragma: no cover
             problems.append(f"BaseView.{suffix}")
+    impl_probe = getattr(_view.BaseView, "_BaseView__timeout_task_impl", None)
+    if (
+        impl_probe is None
+        or not asyncio.iscoroutinefunction(impl_probe)
+        or "self" not in impl_probe.__code__.co_varnames
+    ):  # pragma: no cover
+        problems.append("BaseView._BaseView__timeout_task_impl coroutine")
     if not hasattr(asyncio.timeouts.Timeout(0.0), "_task"):  # pragma: no cover
         problems.append("Timeout._task")
 
@@ -197,7 +204,16 @@ def is_wakeup_callback(callback: Any, args: tuple[Any, ...], waiter: Any, task:
 
 
 def _view_timeout_task_identity(client: discord.Client, task: asyncio.Task[Any]) -> bool:
-    """True when task is some store-registered View/Modal's expiry task."""
+    """True when task is a registered View/Modal's expiry task."""
+    coro = task.get_coro()
+    impl = getattr(_view.BaseView, "_BaseView__timeout_task_impl", None)
+    if impl is not None and getattr(coro, "cr_code", None) is getattr(impl, "__code__", None):
+        owner = getattr(getattr(coro, "cr_frame", None), "f_locals", {}).get("self")
+        if isinstance(owner, _view.BaseView):
+            for name, value in vars(owner).items():
+                if name.endswith("__stopped") and isinstance(value, asyncio.Future) and value.done():
+                    return False
+            return True
     store = getattr(get_state(client), "_view_store", None)
     if store is None:
         return False
@@ -301,9 +317,9 @@ def composed_tasks(task: asyncio.Task[Any], waiter: Any) -> list[Any]:
         if getattr(callback, "__module__", "") == "asyncio.tasks" and getattr(
             callback, "__qualname__", ""
         ).endswith("shield.<locals>._outer_done_callback"):
-            for cell in callback.__closure__ or ():
+            for name, cell in zip(callback.__code__.co_freevars, callback.__closure__ or (), strict=True):
                 value = cell.cell_contents
-                if isinstance(value, asyncio.Future):
+                if name == "inner" and isinstance(value, asyncio.Future):
                     found.append(value)
 
     wait_codes = {

{simcord-2.2.0 → simcord-2.3.0}/src/simcord/actors.py

@@ -9,7 +9,6 @@ channels), then delivered as authentic gateway events.
 from __future__ import annotations
 
 from collections.abc import Sequence
-from functools import wraps
 from typing import TYPE_CHECKING, Any
 
 import discord
@@ -18,7 +17,7 @@ from . import interactions as _interactions
 from .backend import serializers
 from .backend.access import can_access_channel, can_access_message
 from .backend.errors import SetupError
-from .builders import ChannelHandle, GuildHandle, RoleHandle, UserHandle
+from .builders import ChannelHandle, GuildHandle, RoleHandle, UserHandle, _guard_builder_operation
 from .components import validate_modal, walk_components
 from .enums import SELECT_TYPES, AppCommandType, ComponentType, InteractionType
 from .results import InteractionResult, ResponseMessage, to_discord_message
@@ -861,18 +860,6 @@ async def _dispatch_actor_interaction(
     return InteractionResult(actor._env, record)
 
 
-def _guard_actor_operation(method: Any) -> Any:
-    @wraps(method)
-    async def guarded(self: MemberActor, *args: Any, **kwargs: Any) -> Any:
-        token = self._env._begin_operation(method.__name__)
-        try:
-            return await method(self, *args, **kwargs)
-        finally:
-            self._env._end_operation(token)
-
-    return guarded
-
-
 for _operation_name in (
     "send",
     "edit",
@@ -895,4 +882,4 @@ for _operation_name in (
     "subscribe_event",
     "unsubscribe_event",
 ):
-    setattr(MemberActor, _operation_name, _guard_actor_operation(getattr(MemberActor, _operation_name)))
+    setattr(MemberActor, _operation_name, _guard_builder_operation(getattr(MemberActor, _operation_name)))

{simcord-2.2.0 → simcord-2.3.0}/src/simcord/asserts.py

@@ -185,8 +185,8 @@ def assert_error(
 
     discord.py wraps callback failures (e.g. ``CommandInvokeError.original``), so
     the type and code are matched against the error *and* its ``.original``.
-    Returns the matched error. Reading ``env.errors`` marks errors inspected, so
-    this also satisfies the teardown ``check_errors`` guard.
+    Returns the matched error. Reading ``env.errors`` acknowledges the captured
+    prefix with ``future_behavior=True`` (the entire lifetime in legacy mode).
     """
     captured = env.errors
 

{simcord-2.2.0 → simcord-2.3.0}/src/simcord/backend/ops/channels.py

@@ -194,6 +194,7 @@ class ChannelMixin(BackendBase):
         auto_archive_duration: int = 1440,
         message_id: int | None = None,
         applied_tags: Iterable[int] = (),
+        broadcast: bool = True,
     ) -> Channel:
         parent = self.get_channel(parent_id)
         guild = self.get_guild(parent.guild_id)  # type: ignore[arg-type]
@@ -214,10 +215,14 @@ class ChannelMixin(BackendBase):
         self.channels[thread.id] = thread
         self.messages.setdefault(thread.id, {})
         guild.thread_ids.append(thread.id)
+        if broadcast:
+            self.announce_thread_create(thread)
+        return thread
+
+    def announce_thread_create(self, thread: Channel) -> None:
         payload = dict(serializers.thread_payload(self, thread))
         payload["newly_created"] = True
         self.emit("THREAD_CREATE", payload)
-        return thread
 
     # ------------------------------------------------------- stage instances
 

{simcord-2.2.0 → simcord-2.3.0}/src/simcord/backend/ops/messages.py

@@ -51,6 +51,8 @@ class MessageMixin(BackendBase):
                 content=content,
                 embeds=embed_value,
                 poll=poll,
+                attachments=attachments,
+                require_nonempty=True,
             )
         except (ComponentValidationError, TypeError, ValueError) as exc:
             raise _component_error(
@@ -89,16 +91,20 @@ class MessageMixin(BackendBase):
         if channel.is_thread:
             channel.message_count += 1
         if broadcast:
-            payload = dict(serializers.message_payload(self, message))
-            if channel.guild_id is not None:
-                guild = self.guilds[channel.guild_id]
-                if author_id in guild.members:
-                    payload["member"] = serializers.member_payload(
-                        self, guild, guild.members[author_id], with_user=False
-                    )
-            self.emit("MESSAGE_CREATE", payload)
+            self.announce_message_create(message)
         return message
 
+    def announce_message_create(self, message: Message) -> None:
+        channel = self.get_channel(message.channel_id)
+        payload = dict(serializers.message_payload(self, message))
+        if channel.guild_id is not None:
+            guild = self.guilds[channel.guild_id]
+            if message.author_id in guild.members:
+                payload["member"] = serializers.member_payload(
+                    self, guild, guild.members[message.author_id], with_user=False
+                )
+        self.emit("MESSAGE_CREATE", payload)
+
     def _mentions_everyone(self, channel: Channel, author_id: int, content: str) -> bool:
         """An @everyone only actually pings if the author may mention everyone."""
         if "@everyone" not in content and "@here" not in content:
@@ -115,8 +121,10 @@ class MessageMixin(BackendBase):
         embeds = fields["embeds"] if "embeds" in fields else message.embeds
         components = fields["components"] if "components" in fields else message.components
         attachments = fields["attachments"] if "attachments" in fields else message.attachments
-        flags = int(fields["flags"]) if "flags" in fields and fields["flags"] is not None else message.flags
         try:
+            flags = (
+                int(fields["flags"]) if "flags" in fields and fields["flags"] is not None else message.flags
+            )
             normalized_components = validate_message_state(
                 [] if components is None else components,
                 flags=flags,

{simcord-2.2.0 → simcord-2.3.0}/src/simcord/components.py

@@ -551,6 +551,45 @@ def validate_components(components: Any, *, flags: int = 0) -> list[dict[str, An
     return normalized
 
 
+def validate_embeds(embeds: Any) -> None:
+    """Check Discord's per-field and combined embed limits without trimming storage."""
+    if not isinstance(embeds, list):
+        raise ComponentValidationError("embeds must be an array")
+    if len(embeds) > 10:
+        raise ComponentValidationError("embeds: Must be 10 or fewer in length")
+    total = 0
+    for index, embed in enumerate(embeds):
+        if not isinstance(embed, Mapping):
+            raise ComponentValidationError(f"embeds[{index}] must be an object")
+        fields = embed.get("fields") if embed.get("fields") is not None else []
+        if not isinstance(fields, list) or len(fields) > 25:
+            raise ComponentValidationError(f"embeds[{index}].fields: Must be 25 or fewer in length")
+        texts = [("title", embed.get("title"), 256), ("description", embed.get("description"), 4096)]
+        for field_index, field in enumerate(fields):
+            if not isinstance(field, Mapping):
+                raise ComponentValidationError(f"embeds[{index}].fields[{field_index}] must be an object")
+            texts.extend(
+                (f"fields[{field_index}].{key}", field.get(key), limit)
+                for key, limit in (("name", 256), ("value", 1024))
+            )
+        for key, text_key, limit in (("footer", "text", 2048), ("author", "name", 256)):
+            section = embed.get(key) if embed.get(key) is not None else {}
+            if not isinstance(section, Mapping):
+                raise ComponentValidationError(f"embeds[{index}].{key} must be an object")
+            texts.append((f"{key}.{text_key}", section.get(text_key), limit))
+        for path, text, limit in texts:
+            if text is None:
+                continue
+            if not isinstance(text, str):
+                raise ComponentValidationError(f"embeds[{index}].{path} must be a string")
+            length = len(text.strip())
+            if length > limit:
+                raise ComponentValidationError(f"embeds[{index}].{path}: Must be {limit} or fewer characters")
+            total += length
+    if total > 6000:
+        raise ComponentValidationError("embeds: total size of embeds exceeds 6000 characters")
+
+
 def validate_message_state(
     components: Any,
     *,
@@ -560,11 +599,12 @@ def validate_message_state(
     poll: Any = None,
     stickers: Any = None,
     previous_flags: int = 0,
+    attachments: Any = None,
+    require_nonempty: bool = False,
 ) -> list[dict[str, Any]]:
     if content is not None and (not isinstance(content, str) or len(content) > 2000):
         raise _fail("", "content must be a string of 2000 or fewer characters")
-    if not isinstance(embeds, list):
-        raise _fail("", "embeds must be an array")
+    validate_embeds(embeds)
     v2 = bool(int(flags) & COMPONENTS_V2_FLAG)
     if int(previous_flags) & COMPONENTS_V2_FLAG and not v2:
         raise _fail("", "the components_v2 flag cannot be removed")
@@ -572,6 +612,10 @@ def validate_message_state(
         raise _fail("", "components_v2 messages require at least one component")
     if v2 and ((content or "") or embeds or poll is not None or stickers):
         raise _fail("", "components_v2 messages cannot contain content, embeds, polls, or stickers")
+    if require_nonempty and not (
+        (content or "").strip() or embeds or components or attachments or poll is not None
+    ):
+        raise ComponentValidationError("Cannot send an empty message")
     return validate_components(components, flags=int(flags))