negotiate explicitly registered IRC capabilities

docs/plugin-api-additions/async.md

@@ -0,0 +1,30 @@
+# Optional Python asyncio integration
+
+`run_async(coroutine, context=None, interval=10)` returns an AsyncTask with
+`done()`, `cancel()` and `result()`. Each invocation owns a separate event loop
+pumped by an existing main-loop timer. A ready stop callback ensures selector
+polling never blocks the UI. The captured context is restored after every pump;
+a closed context cancels the work. No process-wide event-loop policy is changed.
+
+Existing synchronous scripts are unaffected. Use `asyncio.get_running_loop()`
+inside the coroutine. Child tasks use the same loop/context and are cancelled
+when the main coroutine finishes or the script unloads. Cancellation cleanup is
+bounded; tasks must not suppress cancellation indefinitely. Cleanup uses the
+captured context while it remains open; after it closes, cancellation cleanup uses
+the current valid context. Use explicit Context methods for context-specific
+output in finally blocks, and do not issue context-dependent commands there. This provides normal
+asyncio sockets/timers, not Windows subprocess support or a new HTTP library.
+Asyncio hostname resolution can use its executor; use a resolver appropriate to
+your library if you require no worker threads. Blocking work inside a coroutine
+still blocks the client and must be avoided.
+
+```python
+import asyncio
+import zoitechat
+
+async def later():
+    await asyncio.sleep(1)
+    zoitechat.prnt('Still in the context where this task was started')
+
+task = zoitechat.run_async(later())
+```

docs/plugin-api-additions/caps.md

@@ -0,0 +1,35 @@
+# Script-supported capabilities
+
+`register_capability(name, userdata=None, connection_id=None)` returns a normal
+hook handle. Register before connecting/reconnecting. Core requests the name only
+if advertised in CAP LS or CAP NEW. Existing built-in requests remain enabled;
+SASL and STS registration is rejected so scripts cannot change authentication or
+transport policy through this API. None/-1 means any connection (zero is a valid
+connection ID). Names are lowercase ASCII alphanumerics plus - . / _, 1-200 bytes.
+Duplicate registrations do not duplicate requests for an advertised token.
+
+`unhook(handle)` or script/plugin unload removes future request ownership. It
+intentionally does not disable a capability already acknowledged on a live
+connection, because another plugin/core may depend on it. Registering after CAP
+LS does not retrospectively negotiate an already-advertised capability: reconnect
+or wait for CAP NEW. Core retains ownership of CAP END; this API does not extend
+SASL waiting or delay registration awaiting plugin-only CAP ACKs.
+
+`hook_capability(name, callback, userdata=None, priority=PRI_NORM)` independently
+observes negotiation through existing raw CAP hooks. Callback receives
+`(CapabilityEvent, userdata)` with name, subcommand, value, enabled, context and
+connection_id. LS/NEW mean advertised (`enabled=None`), ACK/LIST mean enabled
+(unless a negative ACK), NAK means rejected and DEL means removed. Callback
+returns are ignored so this observer cannot eat core negotiation. Existing raw
+hooks may still eat CAP before this hook according to their normal priorities.
+
+C: `zoitechat_register_capability(ph, name, flags, connection_id, userdata)`;
+flags=0, ID=-1 for any. Check get_info("api_plugin_caps") for "1" before using
+the appended Windows slot. Use existing server CAP hooks for notifications.
+Requests are split at complete token boundaries within the existing wire limit.
+
+```python
+registration = zoitechat.register_capability('draft/example')
+zoitechat.hook_capability('draft/example', lambda event, data:
+                         event.context.prnt('{}: {}'.format(event.subcommand, event.enabled)))
+```

docs/plugin-api-additions/compatibility.md

@@ -0,0 +1,24 @@
+# Optional plugin API additions (discussion #144)
+
+Existing hooks, callbacks, return values, context lookup, strings and menu behaviour
+remain unchanged. The C plugin function table gains four fixed append-only slots;
+unused slots are NULL. Older binaries use the unchanged prefix. A plugin must check
+the documented get_info() feature key before accessing a new slot on an older host.
+New Python modules are installed by Meson and the existing Windows copy/installer
+pipeline. Only modules present in the installation are exported; imports of
+zoitechat, hexchat and xchat retain their compatibility aliases.
+
+All APIs run on the client main thread unless explicitly documented otherwise.
+New reserved flags must be zero. These changes do not make old API calls thread-safe.
+
+Nested hook dispatch defers deleted-hook reclamation until its outermost return,
+so new observers can safely emit events and unhook themselves or other hooks.
+
+The optional asyncio module requires Python 3.7 or newer; older supported
+interpreters skip that module and retain the existing scripting API.
+
+Python reload drops the script/API modules while retaining the embedding module
+so callback and lib.ph pointer types keep the same CFFI identity.
+
+Server-hook insertion matches both raw and attrs hooks so documented priorities
+are honoured for mixed registrations, including new filtered attrs callbacks.

docs/plugin-api-additions/contexts.md

@@ -0,0 +1,24 @@
+# Connection and context navigation
+
+`get_connections()` returns one Connection snapshot per live connection:
+`id`, `network`, `server`, `context`. Connection IDs distinguish simultaneous
+connections with identical names. Prefer its server-tab context where present.
+`get_connection(context=None)` finds the owner of a live context.
+
+`get_contexts(connection_id=None, types=None)` lists live contexts, optionally
+filtered by connection ID (or a Connection object) and session types: server=1,
+channel=2, query=3. `connection.contexts(types=None)` is a convenience method.
+`find_context_by_id(connection_id, channel=None)` / `connection.find(channel)`
+resolve using that connection's IRC comparator; no channel selects the server tab.
+Missing/closed contexts return None. Existing find_context() remains unchanged.
+
+These helpers use the existing channels list's ID/context fields, so no new C
+context ABI is needed. Snapshots are not persistent IDs across client restarts;
+refresh them after closing/recreating connections. Always check Context.set()
+when explicitly selecting a context that might have closed.
+
+```python
+connection = zoitechat.get_connection()
+for context in connection.contexts(types=(2,)):
+    context.prnt('A channel on this exact connection')
+```

docs/plugin-api-additions/events.md

@@ -0,0 +1,26 @@
+# Semantic IRC hooks
+
+`on_join`, `on_part`, `on_quit`, `on_nick`, `on_kick`, `on_message`, and
+`on_notice` accept `(callback, userdata=None, priority=PRI_NORM)`. The general
+form is `hook_event(command, callback, userdata=None, priority=PRI_NORM)`.
+Callbacks receive `(event, userdata)`, where the immutable IRCEvent has
+command, prefix, nick, user, host, params, context, connection_id and time.
+`params` preserves the trailing parameter, including spaces; JOIN parameters
+also retain extended-join account/realname data when supplied by the server.
+
+These wrappers use existing server hooks, before core command processing;
+return the ordinary EAT_* constants. EAT_ZOITECHAT suppresses the entire IRC
+command (including client state updates), not just its text. Use EAT_NONE for
+observation. Other plugins' priority and eating rules remain unchanged.
+The context is the core-selected context, which can be the server tab when a
+query/channel does not yet exist. QUIT is one event per incoming command,
+not one callback per affected channel. `event.time` is the existing server-time
+attribute (zero when unavailable); other message tags are not exposed here.
+
+```python
+def joined(event, userdata):
+    event.context.prnt('{} joined {}'.format(event.nick, event.params[0]))
+    return zoitechat.EAT_NONE
+
+zoitechat.on_join(joined)
+```

docs/plugin-api-additions/fd.md

@@ -0,0 +1,19 @@
+# Python descriptor hooks
+
+`hook_fd(fd, callback, userdata=None, flags=FD_READ)` returns an ordinary hook
+handle accepted by `unhook()`. Callback arguments are `(fd, ready_flags, userdata)`;
+return True to retain the watch and False/None to remove it. Exceptions print a
+traceback and remove the watch. Unloading the script removes its watches.
+The callback runs in the context captured during registration, and that context
+is restored afterwards. A closed context removes the watch.
+
+Use nonblocking IO and bounded reads/writes. The descriptor belongs to the script;
+unhook before closing it. On Windows socket descriptors use the default flags;
+CRT descriptors need FD_NOTSOCKET. The existing C API uses int descriptors: values
+outside its range are rejected rather than truncated. This does not add threads.
+
+Example:
+```python
+watch = zoitechat.hook_fd(sock.fileno(), on_readable, flags=zoitechat.FD_READ)
+# def on_readable(fd, flags, userdata): ...; return True
+```

docs/plugin-api-additions/filters.md

@@ -0,0 +1,24 @@
+# Core-filtered hooks
+
+Python: `hook_server_filtered(name, callback, userdata=None, priority=PRI_NORM,
+connection_id=None, channel=None)` and `hook_print_filtered(...)`.
+Callbacks match the existing attrs variants: `(word, word_eol, userdata, attrs)`.
+The connection ID distinguishes duplicate names; None/-1 means any connection
+(including connection ID zero). A channel restriction uses that connection's
+IRC comparator. None means any context; an empty string is an exact restriction.
+
+C: the corresponding zoitechat_hook_*_filtered functions accept
+`(ph, name, pri, flags, connection_id, channel, callback, userdata)`;
+flags=0, ID=-1 for any and NULL channel for any. Check
+`get_info("api_context_filters")` for "1" before accessing the new Windows slots.
+
+Filtering takes place before Python/interpreter entry. Existing unrestricted
+hooks, priority, EAT semantics and unload/unhook handling are unchanged.
+Filters refer to the core-selected context, not an IRC target parsed from the
+line: unknown queries/channels can still have a server-tab context, and QUIT
+has its usual single server-hook context. Connection IDs last only this process.
+
+```python
+zoitechat.hook_print_filtered('Channel Message', callback,
+                             connection_id=zoitechat.get_prefs('id'), channel='#zoitechat')
+```

docs/plugin-api-additions/names.md

@@ -0,0 +1,21 @@
+# Explicit IRC comparison keys
+
+`IRCName(text, context=None, casemapping=None, connection_id=None)` is an
+immutable helper, not a str subclass. Construct it explicitly for dictionary/set
+keys; existing get_info/list/event values remain normal strings.
+Equality and hashing include the connection ID and captured casemapping, so
+identical-looking names on different connections are different keys. An IRCName
+never compares equal to a plain str. `str(key)` / `key.text` recover the spelling.
+
+`irc_casefold(text, casemapping='rfc1459')` supports ascii, strict-rfc1459 and
+rfc1459. Only ASCII IRC characters fold; Unicode casefold would be incorrect.
+The new `get_info('casemapping')` reports the comparator actually used by core.
+Current master handles ASCII and RFC1459; this patch does not change its handling
+of advertised strict-rfc1459. An explicit mapping is available for scripts that
+need strict-rfc1459 independently. Keys capture their mapping so hashes stay
+stable; rebuild a collection if the connection's mapping changes.
+
+```python
+seen = {zoitechat.IRCName('[SomeNick]')}
+assert zoitechat.IRCName('{somenick}') in seen  # RFC1459 connection
+```

docs/plugin-api-additions/post.md

@@ -0,0 +1,21 @@
+# Post-display print observers
+
+Python: `hook_print_after(name, callback, userdata=None, priority=PRI_NORM)`.
+The callback is `(word, word_eol, userdata, attrs)`, matching hook_print_attrs().
+It runs after display_event() has handled the text, so prnt() follows the original
+text. Return values are ignored. Events eaten by a pre-hook or hidden by client
+preferences do not invoke these observers. This is post-display notification,
+not a notification that the entire incoming IRC command has finished updating state.
+
+C: `zoitechat_hook_print_after(ph, name, priority, flags, callback, userdata)`;
+flags must be zero. Check `get_info("api_hook_print_after")` for "1" before
+accessing the appended Windows function-table slot. Existing pre-hook timing is
+unchanged. Unhook/unload use existing lifecycle functions. Recursive emission
+skips an already-running observer to prevent it immediately invoking itself.
+
+```python
+def after(word, word_eol, userdata, attrs):
+    zoitechat.prnt('This follows the original channel message')
+
+zoitechat.hook_print_after('Channel Message', after)
+```

plugins/python/_zoitechat.py

@@ -383,3 +383,24 @@ def find_context(server=None, channel=None):
         return None
 
     return Context(ctx)
+
+
+# Optional additive APIs live in separate modules so builds can select features.
+def __load_additive_features():
+    import importlib
+    import os
+
+    for suffix in ('fd', 'events', 'async', 'names', 'contexts',
+                   'post', 'filters', 'caps'):
+        if suffix == 'async' and sys.version_info < (3, 7):
+            continue
+        name = '_zoitechat_' + suffix
+        if not os.path.isfile(os.path.join(os.path.dirname(__file__), name + '.py')):
+            continue
+        module = importlib.import_module(name)
+        for symbol in module.__all__:
+            globals()[symbol] = getattr(module, symbol)
+            __all__.append(symbol)
+
+
+__load_additive_features()

plugins/python/_zoitechat_async.py

@@ -0,0 +1,100 @@
+"""Opt-in asyncio tasks pumped without blocking the client main loop."""
+import asyncio
+import operator
+import traceback
+import _zoitechat as api
+
+__all__ = ['AsyncTask', 'run_async']
+
+
+class AsyncTask:
+    """A script-owned task and isolated event loop; cancel() is cooperative."""
+    def __init__(self, coroutine, plugin, context, interval):
+        self._plugin = plugin
+        self._context = context
+        self._loop = asyncio.new_event_loop()
+        self._task = self._loop.create_task(coroutine)
+        self._closed = False
+        self._unload_hook = api.hook_unload(lambda data: self._close())
+        self._timer_hook = api.hook_timer(interval, self._tick)
+
+    def done(self):
+        return self._task.done()
+
+    def cancel(self):
+        if not self._closed:
+            return self._task.cancel()
+        return False
+
+    def result(self):
+        return self._task.result()
+
+    def _pump(self):
+        # A ready stop callback forces the selector's timeout to zero.
+        self._loop.call_soon(self._loop.stop)
+        self._loop.run_forever()
+
+    def _close(self):
+        if self._closed:
+            return
+        self._closed = True
+        previous = api.get_context()
+        self._context.set()
+        try:
+            pending = asyncio.all_tasks(self._loop)
+            for task in pending:
+                task.cancel()
+            # Bound cleanup work; tasks must cooperate with cancellation.
+            for unused in range(3):
+                if not any(not task.done() for task in pending):
+                    break
+                self._pump()
+            for task in pending:
+                if not task.done():
+                    self._loop.call_exception_handler({
+                        'message': 'Script task ignored cancellation during unload',
+                        'task': task,
+                    })
+        finally:
+            self._loop.close()
+            previous.set()
+
+    def _tick(self, userdata):
+        if self._closed:
+            return False
+        previous = api.get_context()
+        if not self._context.set():
+            self._close()
+            self._plugin.remove_hook(self._unload_hook)
+            return False
+        try:
+            self._pump()
+            if not self._task.done():
+                return True
+            try:
+                self._task.result()
+            except asyncio.CancelledError:
+                pass
+            except Exception:
+                traceback.print_exc()
+            self._close()
+            self._plugin.remove_hook(self._unload_hook)
+            return False
+        except Exception:
+            traceback.print_exc()
+            self._close()
+            self._plugin.remove_hook(self._unload_hook)
+            return False
+        finally:
+            previous.set()
+
+
+def run_async(coroutine, context=None, interval=10):
+    """Schedule a coroutine in a captured context; return an AsyncTask handle."""
+    interval = operator.index(interval)
+    if interval < 1 or interval > 2147483647:
+        raise ValueError('interval must be a positive C int in milliseconds')
+    if not asyncio.iscoroutine(coroutine):
+        raise TypeError('run_async expects a coroutine object')
+    plugin = api.__get_current_plugin()
+    return AsyncTask(coroutine, plugin, context or api.get_context(), interval)

plugins/python/_zoitechat_caps.py

@@ -0,0 +1,64 @@
+"""Script-owned capability requests and structured negotiation observations."""
+from collections import namedtuple
+import operator
+import _zoitechat as api
+from _zoitechat_embedded import ffi, lib
+
+__all__ = ['CapabilityEvent', 'register_capability', 'hook_capability']
+CapabilityEvent = namedtuple('CapabilityEvent',
+                            'name subcommand value enabled context connection_id')
+
+
+def register_capability(name, userdata=None, connection_id=None):
+    """Request an advertised capability on next negotiation; unhook releases ownership."""
+    connection_id = -1 if connection_id is None else operator.index(connection_id)
+    if connection_id < -1 or connection_id > 2147483647:
+        raise ValueError('connection_id must fit the C API; -1 means any')
+    plugin = api.__get_current_plugin()
+    hook = plugin.add_hook(None, userdata)
+    handle = lib.zoitechat_register_capability(lib.ph, name.encode(), 0,
+                                              connection_id, hook.handle)
+    if handle == ffi.NULL:
+        hook.is_unload = True
+        plugin.remove_hook(id(hook))
+        raise ValueError('invalid capability name, reserved capability or connection ID')
+    hook.zoitechat_hook = handle
+    return id(hook)
+
+
+def hook_capability(name, callback, userdata=None, priority=api.PRI_NORM):
+    """Observe LS/NEW/ACK/NAK/DEL/LIST; this hook does not itself request the capability."""
+    if not callable(callback):
+        raise TypeError('callback must be callable')
+
+    def dispatch(word, word_eol, data):
+        if not word_eol:
+            return api.EAT_NONE
+        line = word_eol[0]
+        if line.startswith(':'):
+            unused, separator, line = line.partition(' ')
+        parts = line.split(' ', 3)
+        if len(parts) != 4 or parts[0].upper() != 'CAP':
+            return api.EAT_NONE
+        subcommand, tokens = parts[2].upper(), parts[3]
+        if subcommand not in ('LS', 'NEW', 'ACK', 'NAK', 'DEL', 'LIST'):
+            return api.EAT_NONE
+        if tokens.startswith('* '):
+            tokens = tokens[2:]
+        tokens = tokens.lstrip(':')
+        for token in tokens.split():
+            negative = token.startswith('-')
+            cap, equals, value = token.lstrip('-').partition('=')
+            if cap != name:
+                continue
+            enabled = None
+            if subcommand in ('ACK', 'LIST'):
+                enabled = not negative
+            elif subcommand in ('DEL', 'NAK'):
+                enabled = False
+            event = CapabilityEvent(cap, subcommand, value if equals else None,
+                                    enabled, api.get_context(), api.get_prefs('id'))
+            callback(event, data)
+        return api.EAT_NONE  # observing CAP must not suppress core negotiation
+
+    return api.hook_server('CAP', dispatch, userdata, priority)

plugins/python/_zoitechat_contexts.py

@@ -0,0 +1,75 @@
+"""Navigate live connections by ID instead of ambiguous server/network names."""
+from collections import namedtuple
+import operator
+import _zoitechat as api
+
+__all__ = ['Connection', 'get_connections', 'get_connection', 'get_contexts',
+           'find_context_by_id']
+
+
+class Connection(namedtuple('_Connection', 'id network server context')):
+    __slots__ = ()
+
+    def contexts(self, types=None):
+        return get_contexts(self.id, types)
+
+    def find(self, channel=None):
+        return find_context_by_id(self.id, channel)
+
+
+def _id(connection):
+    return operator.index(connection.id if isinstance(connection, Connection) else connection)
+
+
+def get_connections():
+    """Return one snapshot per live connection, including disconnected ones."""
+    entries = api.get_list('channels')
+    by_id = {}
+    order = []
+    for entry in entries:
+        if entry.id not in by_id:
+            order.append(entry.id)
+        if entry.id not in by_id or entry.type == 1:
+            by_id[entry.id] = Connection(entry.id, entry.network, entry.server,
+                                         entry.context)
+    return [by_id[connection_id] for connection_id in order]
+
+
+def get_connection(context=None):
+    """Find the owning connection of a Context; return None when it has closed."""
+    context = context or api.get_context()
+    for entry in api.get_list('channels'):
+        if entry.context == context:
+            for connection in get_connections():
+                if connection.id == entry.id:
+                    return connection
+    return None
+
+
+def get_contexts(connection_id=None, types=None):
+    """Return contexts, optionally restricted to a connection and session types."""
+    if connection_id is not None:
+        connection_id = _id(connection_id)
+    if types is not None:
+        types = frozenset(types)
+    return [entry.context for entry in api.get_list('channels')
+            if (connection_id is None or entry.id == connection_id)
+            and (types is None or entry.type in types)]
+
+
+def find_context_by_id(connection_id, channel=None):
+    """Resolve a live context on exactly one connection; None selects its server tab."""
+    connection_id = _id(connection_id)
+    previous = api.get_context()
+    try:
+        for entry in api.get_list('channels'):
+            if entry.id != connection_id:
+                continue
+            if channel is None:
+                if entry.type == 1:
+                    return entry.context
+            elif entry.context.set() and api.nickcmp(entry.channel, channel) == 0:
+                return entry.context
+    finally:
+        previous.set()
+    return None

plugins/python/_zoitechat_events.py

@@ -0,0 +1,77 @@
+"""Structured, opt-in hooks before the IRC command's core processing."""
+from collections import namedtuple
+import _zoitechat as api
+
+__all__ = ['IRCEvent', 'hook_event', 'on_join', 'on_part', 'on_quit',
+           'on_nick', 'on_kick', 'on_message', 'on_notice']
+IRCEvent = namedtuple('IRCEvent', 'command prefix nick user host params context connection_id time')
+_SUPPORTED = frozenset(('JOIN', 'PART', 'QUIT', 'NICK', 'KICK', 'PRIVMSG', 'NOTICE'))
+
+
+def _parse(line):
+    prefix = ''
+    if line.startswith(':'):
+        prefix, separator, line = line[1:].partition(' ')
+        if not separator:
+            return None
+    command, separator, rest = line.partition(' ')
+    params = []
+    while rest:
+        rest = rest.lstrip(' ')
+        if rest.startswith(':'):
+            params.append(rest[1:])
+            break
+        param, separator, rest = rest.partition(' ')
+        if param:
+            params.append(param)
+    nick, marker, userhost = prefix.partition('!')
+    user, marker, host = userhost.partition('@')
+    return command.upper(), prefix, nick, user, host, tuple(params)
+
+
+def hook_event(command, callback, userdata=None, priority=api.PRI_NORM):
+    """callback(event, userdata) returns existing EAT_* constants."""
+    command = command.upper()
+    if command not in _SUPPORTED:
+        raise ValueError('unsupported semantic event: ' + command)
+    if not callable(callback):
+        raise TypeError('callback must be callable')
+
+    def dispatch(word, word_eol, data, attrs):
+        if not word_eol:
+            return api.EAT_NONE
+        parsed = _parse(word_eol[0])
+        if parsed is None or parsed[0] != command:
+            return api.EAT_NONE
+        event = IRCEvent(*(parsed + (api.get_context(), api.get_prefs('id'), attrs.time)))
+        return callback(event, data)
+
+    return api.hook_server_attrs(command, dispatch, userdata, priority)
+
+
+def on_join(callback, userdata=None, priority=api.PRI_NORM):
+    return hook_event('JOIN', callback, userdata, priority)
+
+
+def on_part(callback, userdata=None, priority=api.PRI_NORM):
+    return hook_event('PART', callback, userdata, priority)
+
+
+def on_quit(callback, userdata=None, priority=api.PRI_NORM):
+    return hook_event('QUIT', callback, userdata, priority)
+
+
+def on_nick(callback, userdata=None, priority=api.PRI_NORM):
+    return hook_event('NICK', callback, userdata, priority)
+
+
+def on_kick(callback, userdata=None, priority=api.PRI_NORM):
+    return hook_event('KICK', callback, userdata, priority)
+
+
+def on_message(callback, userdata=None, priority=api.PRI_NORM):
+    return hook_event('PRIVMSG', callback, userdata, priority)
+
+
+def on_notice(callback, userdata=None, priority=api.PRI_NORM):
+    return hook_event('NOTICE', callback, userdata, priority)

plugins/python/_zoitechat_fd.py

@@ -0,0 +1,39 @@
+"""File descriptor readiness hooks; callbacks execute on the main thread."""
+import operator
+import _zoitechat as api
+from _zoitechat_embedded import ffi, lib
+
+__all__ = ['FD_READ', 'FD_WRITE', 'FD_EXCEPTION', 'FD_NOTSOCKET', 'hook_fd']
+FD_READ, FD_WRITE, FD_EXCEPTION, FD_NOTSOCKET = 1, 2, 4, 8
+
+
+def hook_fd(fd, callback, userdata=None, flags=FD_READ):
+    """callback(fd, ready_flags, userdata): True keeps the watch, False removes it."""
+    fd = operator.index(fd)
+    flags = operator.index(flags)
+    if fd < 0 or fd > 2147483647:
+        raise ValueError('fd must fit the C API nonnegative int descriptor')
+    if flags & ~15 or not flags & 7:
+        raise ValueError('flags must select READ, WRITE or EXCEPTION')
+    if not callable(callback):
+        raise TypeError('callback must be callable')
+    plugin = api.__get_current_plugin()
+    context = api.get_context()
+
+    def dispatch(descriptor, ready, data):
+        previous = api.get_context()
+        if not context.set():
+            return False
+        try:
+            return callback(descriptor, ready, data)
+        finally:
+            previous.set()
+
+    hook = plugin.add_hook(dispatch, userdata)
+    handle = lib.zoitechat_hook_fd(lib.ph, fd, flags, lib._on_fd_hook, hook.handle)
+    if handle == ffi.NULL:
+        hook.is_unload = True
+        plugin.remove_hook(id(hook))
+        raise RuntimeError('unable to watch descriptor')
+    hook.zoitechat_hook = handle
+    return id(hook)

plugins/python/_zoitechat_filters.py

@@ -0,0 +1,36 @@
+"""Context restrictions evaluated by core before entering Python."""
+import operator
+import _zoitechat as api
+from _zoitechat_embedded import ffi, lib
+
+__all__ = ['hook_server_filtered', 'hook_print_filtered']
+
+
+def _register(name, callback, userdata, priority, connection_id, channel, server):
+    if not callable(callback):
+        raise TypeError('callback must be callable')
+    connection_id = -1 if connection_id is None else operator.index(connection_id)
+    if connection_id < -1 or connection_id > 2147483647:
+        raise ValueError('connection_id must fit the C API; -1 means any')
+    plugin = api.__get_current_plugin()
+    hook = plugin.add_hook(callback, userdata)
+    register = lib.zoitechat_hook_server_filtered if server else lib.zoitechat_hook_print_filtered
+    dispatch = lib._on_server_attrs_hook if server else lib._on_print_attrs_hook
+    handle = register(lib.ph, name.encode(), priority, 0, connection_id,
+                      ffi.NULL if channel is None else channel.encode(), dispatch, hook.handle)
+    if handle == ffi.NULL:
+        hook.is_unload = True
+        plugin.remove_hook(id(hook))
+        raise RuntimeError('unable to install filtered hook')
+    hook.zoitechat_hook = handle
+    return id(hook)
+
+
+def hook_server_filtered(name, callback, userdata=None, priority=api.PRI_NORM,
+                         connection_id=None, channel=None):
+    return _register(name, callback, userdata, priority, connection_id, channel, True)
+
+
+def hook_print_filtered(name, callback, userdata=None, priority=api.PRI_NORM,
+                        connection_id=None, channel=None):
+    return _register(name, callback, userdata, priority, connection_id, channel, False)

plugins/python/_zoitechat_names.py

@@ -0,0 +1,74 @@
+"""Explicit immutable IRC names; existing string-returning APIs are unchanged."""
+import _zoitechat as api
+
+__all__ = ['IRCName', 'irc_casefold']
+
+
+def irc_casefold(text, casemapping='rfc1459'):
+    """Fold ASCII IRC characters only; never apply Unicode lower()/casefold()."""
+    if casemapping not in ('ascii', 'strict-rfc1459', 'rfc1459'):
+        raise ValueError('unsupported IRC casemapping')
+    extra = {'[': '{', ']': '}', '\\': '|'} if casemapping != 'ascii' else {}
+    if casemapping == 'rfc1459':
+        extra['^'] = '~'
+    return ''.join(chr(ord(c) + 32) if 'A' <= c <= 'Z' else extra.get(c, c)
+                   for c in text)
+
+
+class IRCName:
+    """Equality/hash include connection identity and the captured casemapping."""
+    __slots__ = ('_text', '_casemapping', '_connection_id', '_key')
+
+    def __init__(self, text, context=None, casemapping=None, connection_id=None):
+        context = context or api.get_context()
+        if casemapping is None:
+            casemapping = context.get_info('casemapping')
+            if casemapping is None:
+                raise RuntimeError('host does not expose its comparison casemapping')
+        if connection_id is None:
+            previous = api.get_context()
+            if not context.set():
+                raise ValueError('context has closed')
+            try:
+                connection_id = api.get_prefs('id')
+            finally:
+                previous.set()
+        object.__setattr__(self, '_text', text)
+        object.__setattr__(self, '_casemapping', casemapping)
+        object.__setattr__(self, '_connection_id', connection_id)
+        object.__setattr__(self, '_key', (connection_id, casemapping,
+                                       irc_casefold(text, casemapping)))
+
+    def __setattr__(self, name, value):
+        raise AttributeError('IRCName is immutable')
+
+    @property
+    def text(self):
+        return self._text
+
+    @property
+    def casemapping(self):
+        return self._casemapping
+
+    @property
+    def connection_id(self):
+        return self._connection_id
+
+    def __str__(self):
+        return self._text
+
+    def __repr__(self):
+        return 'IRCName({!r}, casemapping={!r}, connection_id={!r})'.format(
+            self._text, self._casemapping, self._connection_id)
+
+    def __eq__(self, other):
+        if not isinstance(other, IRCName):
+            return NotImplemented
+        return self._key == other._key
+
+    def __ne__(self, other):
+        result = self.__eq__(other)
+        return NotImplemented if result is NotImplemented else not result
+
+    def __hash__(self):
+        return hash(self._key)

plugins/python/_zoitechat_post.py

@@ -0,0 +1,21 @@
+"""Opt-in post-display print observers."""
+import _zoitechat as api
+from _zoitechat_embedded import ffi, lib
+
+__all__ = ['hook_print_after']
+
+
+def hook_print_after(name, callback, userdata=None, priority=api.PRI_NORM):
+    """callback(word, word_eol, userdata, attrs); its return value is ignored."""
+    if not callable(callback):
+        raise TypeError('callback must be callable')
+    plugin = api.__get_current_plugin()
+    hook = plugin.add_hook(callback, userdata)
+    handle = lib.zoitechat_hook_print_after(lib.ph, name.encode(), priority, 0,
+                                           lib._on_print_attrs_hook, hook.handle)
+    if handle == ffi.NULL:
+        hook.is_unload = True
+        plugin.remove_hook(id(hook))
+        raise RuntimeError('unable to install post-display hook')
+    hook.zoitechat_hook = handle
+    return id(hook)

plugins/python/generate_plugin.py

@@ -38,6 +38,7 @@ extern "Python" int _on_print_attrs_hook(char **, zoitechat_event_attrs *, void
 extern "Python" int _on_server_hook(char **, char **, void *);
 extern "Python" int _on_server_attrs_hook(char **, char **, zoitechat_event_attrs *, void *);
 extern "Python" int _on_timer_hook(void *);
+extern "Python" int _on_fd_hook(int, int, void *);
 
 extern "Python" int _on_plugin_init(char **, char **, char **, char *, char *);
 extern "Python" int _on_plugin_deinit(void);

plugins/python/meson.build

@@ -27,7 +27,11 @@ python3_source = custom_target('python-bindings',
   command: [find_program('generate_plugin.py'), '@INPUT@', '@OUTPUT@']
 )
 
-install_data(['_zoitechat.py', 'zoitechat.py', 'xchat.py', 'hexchat.py'],
+# Include any selected additive API modules alongside the compatibility modules.
+python_api_files = run_command(python3, '-c',
+  'import glob,sys; print("\\n".join(sorted(glob.glob(sys.argv[1] + "/_zoitechat*.py"))))',
+  meson.current_source_dir(), check: true).stdout().strip().split('\n')
+install_data(python_api_files + ['zoitechat.py', 'xchat.py', 'hexchat.py'],
   install_dir: join_paths(get_option('libdir'), 'zoitechat/python')
 )
 

plugins/python/python.py

@@ -304,6 +304,28 @@ def _on_timer_hook(userdata):
     return 0
 
 
+@ffi.def_extern()
+def _on_fd_hook(fd, flags, userdata):
+    hook = ffi.from_handle(userdata)
+    keep = False
+    try:
+        keep = bool(hook.callback(fd, flags, hook.userdata))
+    except Exception:
+        traceback.print_exc()
+    if not keep:
+        # The C watch removes itself on return; do not unhook it a second time.
+        try:
+            hook.is_unload = True
+            # from_handle() yields a weak proxy: id(proxy) is not id(Hook).
+            for existing in hook.plugin.hooks:
+                if existing == hook:
+                    hook.plugin.remove_hook(id(existing))
+                    break
+        except ReferenceError:
+            pass  # the callback already unhooked itself
+    return int(keep)
+
+
 @ffi.def_extern()
 def _on_say_command(word, word_eol, userdata):
     """Handle input in the special >>python<< tab.
@@ -590,7 +612,12 @@ def _on_plugin_deinit():
     sys.stderr = sys.__stderr__
     pydoc.help = pydoc.Helper()
 
-    for mod in ('_zoitechat', 'zoitechat', 'xchat', '_zoitechat_embedded'):
+    # CFFI callbacks keep the embedding module's ffi/lib identity for the
+    # process lifetime; deleting it creates incompatible types on reload.
+    for mod in ('_zoitechat', 'zoitechat', 'hexchat', 'xchat',
+                '_zoitechat_fd', '_zoitechat_events', '_zoitechat_async',
+                '_zoitechat_names', '_zoitechat_contexts', '_zoitechat_post',
+                '_zoitechat_filters', '_zoitechat_caps'):
         try:
             del sys.modules[mod]
 

plugins/python/python3.vcxproj

@@ -52,6 +52,7 @@
     <None Include="xchat.py" />
     <None Include="hexchat.py" />
     <None Include="_zoitechat.py" />
+    <None Include="_zoitechat_*.py" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="$(IntDir)python.c" />

plugins/python/python38.vcxproj

@@ -52,6 +52,7 @@
     <None Include="xchat.py" />
     <None Include="hexchat.py" />
     <None Include="_zoitechat.py" />
+    <None Include="_zoitechat_*.py" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="$(IntDir)python.c" />

src/common/inbound.c

@@ -41,6 +41,8 @@
 #include "network.h"
 #include "notify.h"
 #include "outbound.h"
+#include <gmodule.h>
+#include "plugin.h"
 #include "inbound.h"
 #include "server.h"
 #include "servlist.h"
@@ -1962,10 +1964,58 @@ inbound_cap_ack (server *serv, char *nick, char *extensions,
 	inbound_toggle_caps (serv, extensions, TRUE);
 }
 
+/* Split requests only at token boundaries, including plugin-added names. */
+static void
+inbound_cap_request_append (server *serv, char *buffer, gsize size,
+                            const char *name, time_t timestamp)
+{
+	if (strlen (buffer) + strlen (name) + 1 >= size)
+	{
+		EMIT_SIGNAL_TIMESTAMP (XP_TE_CAPREQ, serv->server_session,
+			buffer + 9, NULL, NULL, NULL, 0, timestamp);
+		tcp_sendf (serv, "%s\r\n", g_strchomp (buffer));
+		g_strlcpy (buffer, "CAP REQ :", size);
+	}
+	g_strlcat (buffer, name, size);
+	g_strlcat (buffer, " ", size);
+}
+
+static void
+inbound_plugin_cap_new (server *serv, const char *extensions, time_t timestamp)
+{
+	char buffer[500] = "CAP REQ :";
+	char **tokens = g_strsplit (extensions, " ", 0);
+	GHashTable *seen = g_hash_table_new (g_str_hash, g_str_equal);
+	int i;
+	gboolean requested = FALSE;
+	for (i = 0; tokens[i]; i++)
+	{
+		char *value = strchr (tokens[i], '=');
+		if (value)
+			*value = '\0';
+		if (plugin_requests_capability (serv, tokens[i]) &&
+			!g_hash_table_contains (seen, tokens[i]))
+		{
+			g_hash_table_add (seen, tokens[i]);
+			inbound_cap_request_append (serv, buffer, sizeof (buffer), tokens[i], timestamp);
+			requested = TRUE;
+		}
+	}
+	if (requested)
+	{
+		EMIT_SIGNAL_TIMESTAMP (XP_TE_CAPREQ, serv->server_session,
+			buffer + 9, NULL, NULL, NULL, 0, timestamp);
+		tcp_sendf (serv, "%s\r\n", g_strchomp (buffer));
+	}
+	g_hash_table_destroy (seen);
+	g_strfreev (tokens);
+}
+
 void
 inbound_cap_new (server *serv, char *nick, char *extensions,
 					 const message_tags_data *tags_data)
 {
+	gboolean sts_upgrade_triggered = FALSE;
 	if (extensions)
 	{
 		char **tokens = g_strsplit (extensions, " ", 0);
@@ -1977,7 +2027,7 @@ inbound_cap_new (server *serv, char *nick, char *extensions,
 
 			if (!g_strcmp0 (parts[0], "sts") && parts[1] && parts[1][0])
 			{
-				sts_handle_capability (serv, parts[1]);
+				sts_upgrade_triggered |= sts_handle_capability (serv, parts[1]);
 			}
 
 			g_strfreev (parts);
@@ -1986,6 +2036,9 @@ inbound_cap_new (server *serv, char *nick, char *extensions,
 		g_strfreev (tokens);
 	}
 
+	if (extensions && !sts_upgrade_triggered)
+		inbound_plugin_cap_new (serv, extensions, tags_data->timestamp);
+
 	EMIT_SIGNAL_TIMESTAMP (XP_TE_CAPACK, serv->server_session, nick, extensions,
 								  NULL, NULL, 0, tags_data->timestamp);
 
@@ -2116,6 +2169,7 @@ inbound_cap_ls (server *serv, char *nick, char *extensions_str,
 	gboolean want_cap = FALSE; /* format the CAP REQ string based on previous capabilities being requested or not */
 	gboolean sts_upgrade_triggered = FALSE;
 	char **extensions;
+	GString *requests = g_string_new ("");
 	int i;
 
 	if (g_str_has_prefix (extensions_str, "* "))
@@ -2181,7 +2235,7 @@ inbound_cap_ls (server *serv, char *nick, char *extensions_str,
 			}
 			want_cap = TRUE;
 			serv->waiting_on_sasl = TRUE;
-			g_strlcat (buffer, "sasl ", sizeof(buffer));
+			g_string_append (requests, "sasl ");
 			continue;
 		}
 
@@ -2189,28 +2243,44 @@ inbound_cap_ls (server *serv, char *nick, char *extensions_str,
 		{
 			if (!g_strcmp0 (extension, supported_caps[x]))
 			{
-				g_strlcat (buffer, extension, sizeof(buffer));
+				g_string_append (requests, extension);
-				g_strlcat (buffer, " ", sizeof(buffer));
+				g_string_append_c (requests, ' ');
 				want_cap = TRUE;
+				break;
 			}
 		}
+		if (x == G_N_ELEMENTS (supported_caps) && plugin_requests_capability (serv, extension))
+		{
+			g_string_append (requests, extension);
+			g_string_append_c (requests, ' ');
+			want_cap = TRUE;
+		}
+
 	}
 
 	g_strfreev (extensions);
 
 	if (sts_upgrade_triggered)
 	{
+		g_string_free (requests, TRUE);
 		return;
 	}
 
 	if (want_cap)
 	{
+		char **tokens = g_strsplit (requests->str, " ", 0);
+		/* Defer every batch until STS has decided whether to reconnect. */
+		for (i = 0; tokens[i]; i++)
+			if (tokens[i][0])
+				inbound_cap_request_append (serv, buffer, sizeof (buffer), tokens[i], tags_data->timestamp);
+		g_strfreev (tokens);
 		/* buffer + 9 = emit buffer without "CAP REQ :" */
 		EMIT_SIGNAL_TIMESTAMP (XP_TE_CAPREQ, serv->server_session,
 									  buffer + 9, NULL, NULL, NULL, 0,
 									  tags_data->timestamp);
 		tcp_sendf (serv, "%s\r\n", g_strchomp (buffer));
 	}
+	g_string_free (requests, TRUE);
 	if (!serv->waiting_on_sasl && !serv->waiting_on_cap)
 	{
 		/* if we use SASL, CAP END is dealt via raw numerics */

src/common/plugin.c

@@ -99,6 +99,10 @@ struct _zoitechat_hook
 	int tag;				/* for timers & FDs only */
 	int type;			/* HOOK_* */
 	int pri;	/* fd */	/* priority / fd for HOOK_FD only */
+	int cap_connection_id;
+	int connection_filter;
+	char *channel_filter;
+	gboolean context_filtered;
 };
 
 struct _zoitechat_list
@@ -143,6 +147,8 @@ enum
 	HOOK_PRINT_ATTRS  = 1 << 4, /* same as above, with attributes */
 	HOOK_TIMER        = 1 << 5, /* timeouts */
 	HOOK_FD           = 1 << 6, /* sockets & fds */
+	HOOK_PRINT_AFTER  = 1 << 8, /* opt-in post-display observers */
+	HOOK_CAPABILITY   = 1 << 9, /* script-owned CAP requests */
 	HOOK_DELETED      = 1 << 7  /* marked for deletion */
 };
 
@@ -176,6 +182,7 @@ enum
 
 GSList *plugin_list = NULL;	/* export for plugingui.c */
 static GSList *hook_list = NULL;
+static unsigned int plugin_dispatch_depth;
 
 extern const struct prefs vars[];	/* cfgfiles.c */
 
@@ -243,7 +250,7 @@ plugin_list_add (zoitechat_context *ctx, char *filename, const char *name,
 {
 	zoitechat_plugin *pl;
 
-	pl = g_new (zoitechat_plugin, 1);
+	pl = g_new0 (zoitechat_plugin, 1);
 	pl->handle = handle;
 	pl->filename = filename;
 	pl->context = ctx;
@@ -350,6 +357,10 @@ plugin_add (session *sess, char *filename, void *handle, void *init_func,
 		pl->zoitechat_emit_print_attrs = zoitechat_emit_print_attrs;
 		pl->zoitechat_event_attrs_create = zoitechat_event_attrs_create;
 		pl->zoitechat_event_attrs_free = zoitechat_event_attrs_free;
+		pl->zoitechat_register_capability = zoitechat_register_capability;
+		pl->zoitechat_hook_server_filtered = zoitechat_hook_server_filtered;
+		pl->zoitechat_hook_print_filtered = zoitechat_hook_print_filtered;
+		pl->zoitechat_hook_print_after = zoitechat_hook_print_after;
 
 		/* run zoitechat_plugin_init, if it returns 0, close the plugin */
 		if (((zoitechat_init_func *)init_func) (pl, &pl->name, &pl->desc, &pl->version, arg) == 0)
@@ -610,6 +621,7 @@ plugin_hook_run (session *sess, char *name, char *word[], char *word_eol[],
 	zoitechat_hook *hook;
 	int ret, eat = 0;
 
+	plugin_dispatch_depth++;
 	list = hook_list;
 	while (1)
 	{
@@ -619,6 +631,22 @@ plugin_hook_run (session *sess, char *name, char *word[], char *word_eol[],
 
 		hook = list->data;
 		next = list->next;
+		if (hook->context_filtered &&
+			(!is_session (sess) ||
+			 (hook->connection_filter != -1 && hook->connection_filter != sess->server->id) ||
+			 (hook->channel_filter && sess->server->p_cmp (hook->channel_filter, sess->channel))))
+		{
+			list = next;
+			continue; /* filter in C before entering an interpreter */
+		}
+
+		if (type == HOOK_PRINT_AFTER && hook->tag)
+		{
+			list = next;
+			continue; /* no recursive invocation of this same observer */
+		}
+		if (type == HOOK_PRINT_AFTER)
+			hook->tag = 1;
 		hook->pl->context = sess;
 
 		/* run the plugin's callback function */
@@ -627,6 +655,7 @@ plugin_hook_run (session *sess, char *name, char *word[], char *word_eol[],
 		case HOOK_COMMAND:
 			ret = ((zoitechat_cmd_cb *)hook->callback) (word, word_eol, hook->userdata);
 			break;
+		case HOOK_PRINT_AFTER:
 		case HOOK_PRINT_ATTRS:
 			ret = ((zoitechat_print_attrs_cb *)hook->callback) (word, attrs, hook->userdata);
 			break;
@@ -641,6 +670,15 @@ plugin_hook_run (session *sess, char *name, char *word[], char *word_eol[],
 			break;
 		}
 
+		if (type == HOOK_PRINT_AFTER)
+		{
+			hook->tag = 0;
+			if (!is_session (sess))
+				goto xit;
+			list = next;
+			continue; /* display already happened; observers cannot eat it */
+		}
+
 		if ((ret & ZOITECHAT_EAT_ZOITECHAT) && (ret & ZOITECHAT_EAT_PLUGIN))
 		{
 			eat = 1;
@@ -655,6 +693,10 @@ plugin_hook_run (session *sess, char *name, char *word[], char *word_eol[],
 	}
 
 xit:
+	/* Nested callbacks can unhook entries still used by an outer dispatch.
+	 * Keep both hook objects and list links alive until the outermost return. */
+	if (--plugin_dispatch_depth != 0)
+		return eat;
 	/* really remove deleted hooks now */
 	list = hook_list;
 	while (list)
@@ -719,6 +761,15 @@ plugin_emit_print (session *sess, char *word[], time_t server_time)
 							HOOK_PRINT | HOOK_PRINT_ATTRS);
 }
 
+void
+plugin_emit_print_after (session *sess, char *word[], time_t server_time)
+{
+	zoitechat_event_attrs attrs;
+	attrs.server_time_utc = server_time;
+	if (is_session (sess))
+		plugin_hook_run (sess, word[0], word, NULL, &attrs, HOOK_PRINT_AFTER);
+}
+
 int
 plugin_emit_dummy_print (session *sess, char *name)
 {
@@ -806,7 +857,7 @@ plugin_insert_hook (zoitechat_hook *new_hook)
 			break;
 		case HOOK_SERVER:
 		case HOOK_SERVER_ATTRS:
-			new_hook_type = HOOK_SERVER | HOOK_PRINT_ATTRS;
+			new_hook_type = HOOK_SERVER | HOOK_SERVER_ATTRS;
 			break;
 		default:
 			new_hook_type = new_hook->type;
@@ -1018,10 +1069,87 @@ zoitechat_unhook (zoitechat_plugin *ph, zoitechat_hook *hook)
 
 	g_free (hook->name);	/* NULL for timers & fds */
 	g_free (hook->help_text);	/* NULL for non-commands */
+	g_free (hook->channel_filter);
+	hook->channel_filter = NULL;
 
 	return hook->userdata;
 }
 
+zoitechat_hook *
+zoitechat_hook_print_after (zoitechat_plugin *ph, const char *name, int pri,
+                          int flags, zoitechat_print_attrs_cb *callback, void *userdata)
+{
+	if (flags != 0 || !name || !callback)
+		return NULL;
+	return plugin_add_hook (ph, HOOK_PRINT_AFTER, pri, name, NULL, callback, 0, userdata);
+}
+
+static zoitechat_hook *
+plugin_add_filtered_hook (zoitechat_plugin *ph, const char *name, int pri,
+                         int flags, int connection_id, const char *channel,
+                         int type, void *callback, void *userdata)
+{
+	zoitechat_hook *hook;
+	if (flags != 0 || connection_id < -1 || !name || !callback)
+		return NULL;
+	hook = plugin_add_hook (ph, type, pri, name, NULL, callback, 0, userdata);
+	hook->context_filtered = TRUE;
+	hook->connection_filter = connection_id;
+	hook->channel_filter = g_strdup (channel);
+	return hook;
+}
+
+zoitechat_hook *
+zoitechat_hook_server_filtered (zoitechat_plugin *ph, const char *name, int pri,
+                               int flags, int connection_id, const char *channel,
+                               zoitechat_serv_attrs_cb *callback, void *userdata)
+{
+	return plugin_add_filtered_hook (ph, name, pri, flags, connection_id, channel,
+		HOOK_SERVER_ATTRS, callback, userdata);
+}
+
+zoitechat_hook *
+zoitechat_hook_print_filtered (zoitechat_plugin *ph, const char *name, int pri,
+                              int flags, int connection_id, const char *channel,
+                              zoitechat_print_attrs_cb *callback, void *userdata)
+{
+	return plugin_add_filtered_hook (ph, name, pri, flags, connection_id, channel,
+		HOOK_PRINT_ATTRS, callback, userdata);
+}
+
+zoitechat_hook *
+zoitechat_register_capability (zoitechat_plugin *ph, const char *name, int flags,
+                              int connection_id, void *userdata)
+{
+	const unsigned char *p;
+	zoitechat_hook *hook;
+	if (flags != 0 || connection_id < -1 || !name || !name[0] || strlen (name) > 200 ||
+		strcmp (name, "sasl") == 0 || strcmp (name, "sts") == 0)
+		return NULL; /* authentication and transport policy belong to core */
+	for (p = (const unsigned char *)name; *p; p++)
+		if (!g_ascii_islower (*p) && !g_ascii_isdigit (*p) &&
+			*p != '-' && *p != '.' && *p != '/' && *p != '_')
+			return NULL;
+	hook = plugin_add_hook (ph, HOOK_CAPABILITY, 0, name, NULL, NULL, 0, userdata);
+	hook->cap_connection_id = connection_id;
+	return hook;
+}
+
+gboolean
+plugin_requests_capability (server *serv, const char *name)
+{
+	GSList *entry;
+	for (entry = hook_list; entry; entry = entry->next)
+	{
+		zoitechat_hook *hook = entry->data;
+		if (hook && hook->type == HOOK_CAPABILITY &&
+			(hook->cap_connection_id == -1 || hook->cap_connection_id == serv->id) &&
+			strcmp (hook->name, name) == 0)
+			return TRUE;
+	}
+	return FALSE;
+}
+
 zoitechat_hook *
 zoitechat_hook_command (zoitechat_plugin *ph, const char *name, int pri,
 						  zoitechat_cmd_cb *callb, const char *help_text, void *userdata)
@@ -1181,6 +1309,25 @@ zoitechat_get_info (zoitechat_plugin *ph, const char *id)
 		return text_find_format_string (e);
 	}
 
+	/* Report the comparison actually used by this connection, not an
+	 * advertised mapping that the current core does not implement. */
+	if (strcmp (id, "casemapping") == 0)
+	{
+		if (!is_session (ph->context))
+			return NULL;
+		return ph->context->server->p_cmp == g_ascii_strcasecmp
+			? "ascii" : "rfc1459";
+	}
+
+	if (strcmp (id, "api_hook_print_after") == 0)
+		return "1";
+
+	if (strcmp (id, "api_context_filters") == 0)
+		return "1";
+
+	if (strcmp (id, "api_plugin_caps") == 0)
+		return "1";
+
 	hash = str_hash (id);
 	/* do the session independant ones first */
 	switch (hash)

src/common/plugin.h

@@ -150,6 +150,15 @@ struct _zoitechat_plugin
 	void (*zoitechat_event_attrs_free) (zoitechat_plugin *ph,
 									  zoitechat_event_attrs *attrs);
 
+	/* Additive API slots: append only; old binary offsets are unchanged. */
+	zoitechat_hook *(*zoitechat_hook_print_after) (zoitechat_plugin *, const char *, int,
+		int, int (*)(char *[], zoitechat_event_attrs *, void *), void *);
+	zoitechat_hook *(*zoitechat_hook_server_filtered) (zoitechat_plugin *, const char *, int,
+		int, int, const char *, int (*)(char *[], char *[], zoitechat_event_attrs *, void *), void *);
+	zoitechat_hook *(*zoitechat_hook_print_filtered) (zoitechat_plugin *, const char *, int,
+		int, int, const char *, int (*)(char *[], zoitechat_event_attrs *, void *), void *);
+	zoitechat_hook *(*zoitechat_register_capability) (zoitechat_plugin *, const char *, int, int, void *);
+
 	/* PRIVATE FIELDS! */
 	void *handle;		/* from dlopen */
 	char *filename;	/* loaded from */
@@ -174,6 +183,8 @@ int plugin_emit_command (session *sess, char *name, char *word[], char *word_eol
 int plugin_emit_server (session *sess, char *name, char *word[], char *word_eol[],
 						time_t server_time);
 int plugin_emit_print (session *sess, char *word[], time_t server_time);
+gboolean plugin_requests_capability (server *serv, const char *name);
+void plugin_emit_print_after (session *sess, char *word[], time_t server_time);
 int plugin_emit_dummy_print (session *sess, char *name);
 int plugin_emit_keypress (session *sess, unsigned int state, unsigned int keyval, gunichar key);
 GList* plugin_command_list(GList *tmp_list);

src/common/text.c

@@ -2306,6 +2306,7 @@ text_emit (int index, session *sess, char *a, char *b, char *c, char *d,
 	if (!prefs.hex_away_omit_alerts || !sess->server->is_away)
 		sound_play_event (index);
 	display_event (sess, index, word, stripcolor_args, timestamp);
+	plugin_emit_print_after (sess, word, timestamp);
 }
 
 char *

src/common/zoitechat-plugin.h

@@ -193,10 +193,39 @@ struct _zoitechat_plugin
 	zoitechat_event_attrs *(*zoitechat_event_attrs_create) (zoitechat_plugin *ph);
 	void (*zoitechat_event_attrs_free) (zoitechat_plugin *ph,
 									  zoitechat_event_attrs *attrs);
+	/* Additive API slots: append only; old binary offsets are unchanged. */
+	zoitechat_hook *(*zoitechat_hook_print_after) (zoitechat_plugin *, const char *, int,
+		int, int (*)(char *[], zoitechat_event_attrs *, void *), void *);
+	zoitechat_hook *(*zoitechat_hook_server_filtered) (zoitechat_plugin *, const char *, int,
+		int, int, const char *, int (*)(char *[], char *[], zoitechat_event_attrs *, void *), void *);
+	zoitechat_hook *(*zoitechat_hook_print_filtered) (zoitechat_plugin *, const char *, int,
+		int, int, const char *, int (*)(char *[], zoitechat_event_attrs *, void *), void *);
+	zoitechat_hook *(*zoitechat_register_capability) (zoitechat_plugin *, const char *, int, int, void *);
+
 };
 #endif
 
 
+/* api_hook_print_after=1: observer returns are ignored; flags must be zero. */
+zoitechat_hook *zoitechat_hook_print_after (zoitechat_plugin *ph,
+    const char *name, int pri, int flags,
+    int (*callback) (char *word[], zoitechat_event_attrs *attrs, void *userdata),
+    void *userdata);
+
+/* api_context_filters=1: connection_id -1 is any; NULL channel is any. */
+zoitechat_hook *zoitechat_hook_server_filtered (zoitechat_plugin *ph,
+    const char *name, int pri, int flags, int connection_id, const char *channel,
+    int (*callback) (char *word[], char *word_eol[], zoitechat_event_attrs *attrs, void *userdata),
+    void *userdata);
+zoitechat_hook *zoitechat_hook_print_filtered (zoitechat_plugin *ph,
+    const char *name, int pri, int flags, int connection_id, const char *channel,
+    int (*callback) (char *word[], zoitechat_event_attrs *attrs, void *userdata),
+    void *userdata);
+
+/* api_plugin_caps=1: register before CAP LS; flags=0, connection_id=-1 for any. */
+zoitechat_hook *zoitechat_register_capability (zoitechat_plugin *ph,
+    const char *name, int flags, int connection_id, void *userdata);
+
 zoitechat_hook *
 zoitechat_hook_command (zoitechat_plugin *ph,
 		    const char *name,
@@ -416,6 +445,10 @@ zoitechat_pluginpref_list (zoitechat_plugin *ph,
 #define zoitechat_hook_server ((ZOITECHAT_PLUGIN_HANDLE)->zoitechat_hook_server)
 #define zoitechat_hook_server_attrs ((ZOITECHAT_PLUGIN_HANDLE)->zoitechat_hook_server_attrs)
 #define zoitechat_hook_print ((ZOITECHAT_PLUGIN_HANDLE)->zoitechat_hook_print)
+#define zoitechat_register_capability ((ZOITECHAT_PLUGIN_HANDLE)->zoitechat_register_capability)
+#define zoitechat_hook_server_filtered ((ZOITECHAT_PLUGIN_HANDLE)->zoitechat_hook_server_filtered)
+#define zoitechat_hook_print_filtered ((ZOITECHAT_PLUGIN_HANDLE)->zoitechat_hook_print_filtered)
+#define zoitechat_hook_print_after ((ZOITECHAT_PLUGIN_HANDLE)->zoitechat_hook_print_after)
 #define zoitechat_hook_print_attrs ((ZOITECHAT_PLUGIN_HANDLE)->zoitechat_hook_print_attrs)
 #define zoitechat_hook_timer ((ZOITECHAT_PLUGIN_HANDLE)->zoitechat_hook_timer)
 #define zoitechat_hook_fd ((ZOITECHAT_PLUGIN_HANDLE)->zoitechat_hook_fd)

win32/copy/copy.vcxproj

@@ -90,6 +90,7 @@
       <MSWindowsTheme Include="$(DepsRoot)\share\themes\MS-Windows\**\*" />
       <HicolorIcons Include="$(DepsRoot)\share\icons\hicolor\index.theme" />
       <HicolorIcons Include="$(DepsRoot)\share\icons\hicolor\**\*.*" />
+      <PythonAdditiveApis Include="..\..\plugins\python\_zoitechat_*.py" />
     </ItemGroup>
 
     <Copy SourceFiles="@(None)" DestinationFolder="$(ZoiteChatRel)" />
@@ -115,6 +116,7 @@
     <Copy SourceFiles="..\..\plugins\python\hexchat.py" DestinationFolder="$(ZoiteChatRel)\python" Condition="'$(Python3Enabled)'=='true' or '$(Python38Enabled)'=='true'" />
     <Copy SourceFiles="..\..\plugins\python\zoitechat.py" DestinationFolder="$(ZoiteChatRel)\python" Condition="'$(Python3Enabled)'=='true' or '$(Python38Enabled)'=='true'" />
     <Copy SourceFiles="..\..\plugins\python\_zoitechat.py" DestinationFolder="$(ZoiteChatRel)\python" Condition="'$(Python3Enabled)'=='true' or '$(Python38Enabled)'=='true'" />
+    <Copy SourceFiles="@(PythonAdditiveApis)" DestinationFolder="$(ZoiteChatRel)\python" Condition="('$(Python3Enabled)'=='true' or '$(Python38Enabled)'=='true') and '@(PythonAdditiveApis)' != ''" />
 
     <WriteLinesToFile File="$(ZoiteChatRel)portable-mode" Lines="2" Overwrite="true" />