Read each membership's last value from mesh-grants' own state and say it on its subject without the assignments stream, so memberships keep flowing once nats_stream_remove takes the stream at the lease write (issue 774, research 072 row 33)

modules/mesh-grants/cmd/mesh-grants/main.go

@@ -4,8 +4,8 @@
 // list and each manifest's buckets, logs and streams with the bus composer the controller uses (mesh-sdk buscompose).
 //
 // **Memberships are published for real** (the operator, 2026-10-25 22:31): since release 6 nobody publishes them, so a
-// module placed since cannot serve its seat or reach a new state. Each is published on the assignments stream only when
-// it differs from the one last published there. **A bucket, log or stream a manifest declares that the bus lacks is
+// module placed since cannot serve its seat or reach a new state. Each is published in the part's own state memberships,
+// and said on its subject, only when it differs from the one last published there. **A bucket, log or stream a manifest declares that the bus lacks is
 // created** (the operator, 2026-10-26 08:54; issue 1790), once per manifest, with the manifest's limits, on the event
 // that brought the manifest; one the bus holds is never changed. **The user list is written sealed to the bus node**
 // (ADR 0547 clause 7) as an object of the part's own bucket named in `user-list.sealed`, which the bus node follows only
@@ -112,7 +112,7 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro
 	}
 	bus := newBusReader(ctx, js)
 	f.Part = &grants.Part{Read: bus, Call: conn, Store: ownStore{conn}, Emit: emitting{conn},
-		Publish: memberships{ctx: ctx, nc: nc, js: js}, Create: creating{ctx: ctx, js: js}, Consumers: creating{ctx: ctx, js: js},
+		Publish: memberships{nc: nc}, Create: creating{ctx: ctx, js: js}, Consumers: creating{ctx: ctx, js: js},
 		Objects: sealedObjects{ctx: ctx, js: js}, Logf: logger.Printf,
 		Bus: grants.BusAddress{URL: account.URL, Fingerprint: account.Fingerprint}}
 	f.Watch = bus

modules/mesh-grants/cmd/mesh-grants/publish.go

@@ -1,55 +1,24 @@
 package main
 
 import (
-	"context"
-	"errors"
 	"fmt"
-	"strconv"
 
 	"github.com/nats-io/nats.go"
-	"github.com/nats-io/nats.go/jetstream"
 
 	"git.novox.be/novox/mesh-sdk/go/membership"
 )
 
-// memberships publishes each membership on the assignments stream, last per subject, over the one last read there
-// (ExpectLastSequencePerSubject, so a membership another writer published meanwhile is not overwritten, issues 930 and
-// 934), and reads the last one by a direct get of its subject. The one place the part publishes on the bus.
+// memberships says each membership the part wrote to its state on its subject, `mesh.assignment.<node>.<module>`, as a
+// plain message: a notice for a runtime that follows the subject alone, which the assignments stream also keeps while it
+// exists. It reads nothing there and asks no stream for an acknowledgement, so the stream's removal at the lease write
+// (research 072 row 33) stops no membership (issue 774). The one place the part publishes a membership on the bus.
 type memberships struct {
-	ctx context.Context
-	nc  *nats.Conn
-	js  jetstream.JetStream
+	nc *nats.Conn
 }
 
-func (m memberships) LastMembership(node, module string) ([]byte, uint64, bool, error) {
-	ctx, cancel := context.WithTimeout(m.ctx, requestWithin)
-	defer cancel()
-	msg, err := m.nc.RequestWithContext(ctx, membership.DirectGetSubject(node, module), nil)
-	if err != nil {
-		if errors.Is(err, context.DeadlineExceeded) {
-			err = fmt.Errorf("no answer in %s: a read the bus refuses is answered by none (%w)", requestWithin, err)
-		}
-		return nil, 0, false, err
-	}
-	switch status := msg.Header.Get("Status"); status {
-	case "":
-	case "404":
-		return nil, 0, false, nil
-	default:
-		return nil, 0, false, fmt.Errorf("the assignments stream answered %s %s", status, msg.Header.Get("Description"))
-	}
-	seq, err := strconv.ParseUint(msg.Header.Get("Nats-Sequence"), 10, 64)
-	if err != nil {
-		return nil, 0, false, fmt.Errorf("the membership of %s on %s carries no sequence", module, node)
-	}
-	return msg.Data, seq, true, nil
-}
-
-func (m memberships) PublishMembership(node, module string, body []byte, after uint64) error {
-	ctx, cancel := context.WithTimeout(m.ctx, requestWithin)
-	defer cancel()
-	if _, err := m.js.Publish(ctx, membership.Subject(node, module), body, jetstream.WithExpectLastSequencePerSubject(after)); err != nil {
-		return fmt.Errorf("the membership of %s on %s after sequence %d: %w", module, node, after, err)
+func (m memberships) PublishMembership(node, module string, body []byte) error {
+	if err := m.nc.Publish(membership.Subject(node, module), body); err != nil {
+		return fmt.Errorf("the membership of %s on %s: %w", module, node, err)
 	}
 	return nil
 }