@synopackageland/cli 0.4.0 → 0.5.0

package/templates/native-go/backend/internal/helper/grant_delivery_methods.go

@@ -0,0 +1,273 @@
+package helper
+
+import (
+	"context"
+	"crypto/rand"
+	"encoding/hex"
+	"io"
+	"net"
+	"slices"
+	"time"
+)
+
+func validDeliveryEpoch(i Inventory, epoch string) Code {
+	if !i.Valid() || i.Protocol != DataProtocol {
+		return ErrIncompatible
+	}
+	if !digestPattern.MatchString(epoch) {
+		return ErrInvalid
+	}
+	return ""
+}
+
+func newOperationTickets(i Inventory, epoch string) (*operationTickets, Code) {
+	if c := validDeliveryEpoch(i, epoch); c != "" {
+		return nil, c
+	}
+	return &operationTickets{inventory: i, epoch: epoch, now: time.Now, random: rand.Reader, issued: map[string]issuedOperationTicket{}}, ""
+}
+
+func deliveryActorCode(a NativeActor, now time.Time) Code {
+	if !a.valid || !a.account.Enabled || a.UID() == 0 || a.GID() == 0 {
+		return ErrDenied
+	}
+	if a.Principal().Kind != "local" {
+		return ErrUnsupported
+	}
+	if !allReferences(a.Principal().SubjectRef, a.Principal().InstanceRef, a.SessionRef()) || a.account.Groups == nil {
+		return ErrSuspended
+	}
+	if !nativeFresh(a.account.CheckedAt, now) {
+		return ErrStale
+	}
+	return ""
+}
+
+// issue is called only after trusted native/App/ACL observation, never in
+// response to caller identity claims. It does not grant filesystem admission.
+// A caller ticket is refused; the returned control contains a CSPRNG ticket
+// bound to that exact decoded request, including its argument bytes.
+func (t *operationTickets) issue(ctx context.Context, actor NativeActor, request DataRequest) (DataRequest, Code) {
+	if t == nil {
+		return DataRequest{}, ErrUnavailable
+	}
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	if t.closed || t.now == nil || t.random == nil || t.issued == nil {
+		return DataRequest{}, ErrUnavailable
+	}
+	if code := nativeContextCode(ctx); code != "" {
+		return DataRequest{}, code
+	}
+	if code := deliveryActorCode(actor, t.now()); code != "" {
+		return DataRequest{}, code
+	}
+	if request.Inventory != t.inventory || request.Epoch != t.epoch {
+		return DataRequest{}, ErrStale
+	}
+	if request.Ticket != "" {
+		return DataRequest{}, ErrInvalid
+	}
+	full := len(t.issued)-t.streamIssued >= MaxReplayEntries
+	if request.Op == ActionReadStream || request.Op == ActionWriteStream {
+		full = t.streamIssued >= MaxStreamReplayEntries
+	}
+	if full {
+		return DataRequest{}, ErrBusy
+	}
+	// Validate before drawing randomness. The temporary reference is never used
+	// as a credential or published; syntax validation requires a ticket-shaped ID.
+	request.Ticket = t.epoch
+	if code := validateOperationRequest(request, t.writes); code != "" {
+		return DataRequest{}, code
+	}
+	if !request.Op.ReadOnly() && !t.writes.allows(request.Op) {
+		return DataRequest{}, ErrUnsupported
+	}
+	var token [32]byte
+	if _, err := io.ReadFull(t.random, token[:]); err != nil {
+		return DataRequest{}, ErrUnavailable
+	}
+	if code := nativeContextCode(ctx); code != "" {
+		return DataRequest{}, code
+	}
+	now := t.now()
+	if code := deliveryActorCode(actor, now); code != "" {
+		return DataRequest{}, code
+	}
+	request.Ticket = hex.EncodeToString(token[:])
+	if _, exists := t.issued[request.Ticket]; exists {
+		return DataRequest{}, ErrUnavailable
+	}
+	request.Args = slices.Clone(request.Args)
+	binding := TicketBinding{Inventory: request.Inventory, Epoch: request.Epoch, SubjectRef: actor.Principal().SubjectRef, SessionRef: actor.SessionRef(), Action: request.Op, GrantID: request.GrantID, GrantRevision: request.GrantRevision, OperationID: request.OperationID, Nonce: request.Nonce, Ticket: request.Ticket, RequestDigest: request.Digest(), ExpiresAt: now.Add(IntentTTL)}
+	if binding.RequestDigest == "" {
+		return DataRequest{}, ErrInvalid
+	}
+	t.issued[request.Ticket] = issuedOperationTicket{binding: binding, principal: actor.Principal()}
+	if request.Op == ActionReadStream || request.Op == ActionWriteStream {
+		t.streamIssued++
+	}
+	return request, ""
+}
+
+// consume burns only an exact issued control. S3 must still freshly revalidate
+// native/App/ACL/continuity and consume its own admission history under its gate.
+// An admission failure may burn this ticket; retries require a new ticket.
+func (t *operationTickets) consume(ctx context.Context, actor NativeActor, request DataRequest) (TicketBinding, Code) {
+	if t == nil {
+		return TicketBinding{}, ErrUnavailable
+	}
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	if t.closed || t.now == nil || t.issued == nil {
+		return TicketBinding{}, ErrUnavailable
+	}
+	if code := nativeContextCode(ctx); code != "" {
+		return TicketBinding{}, code
+	}
+	now := t.now()
+	if code := deliveryActorCode(actor, now); code != "" {
+		return TicketBinding{}, code
+	}
+	if code := validateOperationRequest(request, t.writes); code != "" {
+		return TicketBinding{}, code
+	}
+	issued, ok := t.issued[request.Ticket]
+	if !ok {
+		return TicketBinding{}, ErrDenied
+	}
+	b := issued.binding
+	if actor.Principal() != issued.principal || actor.SessionRef() != b.SessionRef || request.Digest() != b.RequestDigest {
+		return TicketBinding{}, ErrDenied
+	}
+	if issued.used {
+		return TicketBinding{}, ErrReplay
+	}
+	if !now.Before(b.ExpiresAt) {
+		return TicketBinding{}, ErrExpired
+	}
+	if b.ExpiresAt.Sub(now) > IntentTTL {
+		return TicketBinding{}, ErrStale
+	}
+	issued.used = true
+	t.issued[request.Ticket] = issued
+	return b, ""
+}
+func (t *operationTickets) close() {
+	if t == nil {
+		return
+	}
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	t.closed = true
+}
+
+func newOutputHandoff(i Inventory, epoch string) (*outputHandoff, Code) {
+	if code := validDeliveryEpoch(i, epoch); code != "" {
+		return nil, code
+	}
+	return &outputHandoff{inventory: i, epoch: epoch, now: time.Now, entries: map[string]operationOutput{}}, ""
+}
+func validOutputBinding(b operationBinding, i Inventory, epoch string) bool {
+	return b.Inventory == i && b.Epoch == epoch && allReferences(b.OperationID, b.Nonce, b.GrantID) && b.GrantRevision > 0
+}
+
+// register takes ownership even on rejection. Caller must have authenticated
+// the fixed owned peer and associated this endpoint with the admitted request.
+// Never call this with a browser-supplied operation binding or remote address.
+func (h *outputHandoff) register(b operationBinding, conn net.Conn) (code Code) {
+	if conn == nil {
+		return ErrInvalid
+	}
+	defer func() {
+		if code != "" {
+			conn.Close()
+		}
+	}()
+	if h == nil {
+		return ErrUnavailable
+	}
+	h.mu.Lock()
+	defer h.mu.Unlock()
+	if h.closed || h.now == nil || h.entries == nil {
+		return ErrUnavailable
+	}
+	if !validOutputBinding(b, h.inventory, h.epoch) {
+		return ErrDenied
+	}
+	if _, ok := h.entries[b.OperationID]; ok {
+		return ErrReplay
+	}
+	if len(h.entries) >= MaxReplayEntries {
+		return ErrBusy
+	}
+	now := h.now()
+	if now.IsZero() {
+		return ErrUnavailable
+	}
+	h.entries[b.OperationID] = operationOutput{binding: b, conn: conn, expires: now.Add(BoundedTimeout)}
+	return ""
+}
+
+// take transfers ownership to S2. All net.Conn.Close calls occur after dropping
+// the handoff lock. Close/timeout here is not child-reap or Q evidence.
+func (h *outputHandoff) take(b operationBinding) (net.Conn, Code) {
+	if h == nil {
+		return nil, ErrUnavailable
+	}
+	h.mu.Lock()
+	if h.closed || h.now == nil || h.entries == nil {
+		h.mu.Unlock()
+		return nil, ErrUnavailable
+	}
+	entry, ok := h.entries[b.OperationID]
+	if !validOutputBinding(b, h.inventory, h.epoch) || !ok || entry.binding != b {
+		h.mu.Unlock()
+		return nil, ErrDenied
+	}
+	if entry.taken {
+		h.mu.Unlock()
+		return nil, ErrReplay
+	}
+	if now := h.now(); now.IsZero() || !now.Before(entry.expires) || entry.expires.Sub(now) > BoundedTimeout {
+		conn := entry.conn
+		entry.conn = nil
+		entry.taken = true
+		h.entries[b.OperationID] = entry
+		h.mu.Unlock()
+		if conn != nil {
+			conn.Close()
+		}
+		return nil, ErrExpired
+	}
+	if entry.conn == nil {
+		h.mu.Unlock()
+		return nil, ErrUnavailable
+	}
+	conn := entry.conn
+	entry.conn = nil
+	entry.taken = true
+	h.entries[b.OperationID] = entry
+	h.mu.Unlock()
+	return conn, ""
+}
+func (h *outputHandoff) close() {
+	if h == nil {
+		return
+	}
+	h.mu.Lock()
+	h.closed = true
+	var pending []net.Conn
+	for id, entry := range h.entries {
+		if entry.conn != nil {
+			pending = append(pending, entry.conn)
+			entry.conn = nil
+			h.entries[id] = entry
+		}
+	}
+	h.mu.Unlock()
+	for _, conn := range pending {
+		conn.Close()
+	}
+}

package/templates/native-go/backend/internal/helper/grant_delivery_test.go

@@ -0,0 +1,322 @@
+package helper
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net"
+	"slices"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+)
+
+func deliveryFixture(t *testing.T) (*operationTickets, NativeActor, DataRequest, time.Time) {
+	t.Helper()
+	provider, _, _, carriers, now := nativeFixture()
+	actor, code := provider.Resolve(context.Background(), carriers)
+	if code != "" {
+		t.Fatal(code)
+	}
+	request, _, _ := validRequestAndTicket(t)
+	request.Ticket = ""
+	tickets, code := newOperationTickets(request.Inventory, request.Epoch)
+	if code != "" {
+		t.Fatal(code)
+	}
+	tickets.now = func() time.Time { return now }
+	return tickets, actor, request, now
+}
+
+func TestOperationTicketsServerIssuedAndCompleteBinding(t *testing.T) {
+	tickets, actor, request, _ := deliveryFixture(t)
+	issued, code := tickets.issue(context.Background(), actor, request)
+	if code != "" || !digestPattern.MatchString(issued.Ticket) {
+		t.Fatal(code, issued.Ticket)
+	}
+	original := issued
+	issued.Args = slices.Clone(issued.Args)
+	issued.Args[0] = ' '
+	if _, code = tickets.consume(context.Background(), actor, issued); code == "" {
+		t.Fatal("changed arguments accepted")
+	}
+	proof, code := tickets.consume(context.Background(), actor, original)
+	if code != "" || proof.Ticket != original.Ticket || proof.RequestDigest != original.Digest() || proof.SubjectRef != actor.Principal().SubjectRef || proof.SessionRef != actor.SessionRef() {
+		t.Fatal(code, proof)
+	}
+	if _, code = tickets.consume(context.Background(), actor, original); code != ErrReplay {
+		t.Fatal("replay", code)
+	}
+	if _, code = tickets.consume(context.Background(), actor, request); code == "" {
+		t.Fatal("missing ticket accepted")
+	}
+}
+
+func TestOperationTicketsRejectUnknownProofAndEverySubstitution(t *testing.T) {
+	mutations := []struct {
+		name   string
+		mutate func(*DataRequest, *NativeActor)
+	}{
+		{"inventory", func(r *DataRequest, a *NativeActor) { r.Inventory.Version = "9.0.0-9999" }},
+		{"epoch", func(r *DataRequest, a *NativeActor) { r.Epoch = strings.Repeat("a", 64) }},
+		{"grant", func(r *DataRequest, a *NativeActor) { r.GrantID = strings.Repeat("a", 64) }},
+		{"revision", func(r *DataRequest, a *NativeActor) { r.GrantRevision++ }},
+		{"operation", func(r *DataRequest, a *NativeActor) { r.OperationID = strings.Repeat("a", 64) }},
+		{"nonce", func(r *DataRequest, a *NativeActor) { r.Nonce = strings.Repeat("a", 64) }},
+		{"ticket", func(r *DataRequest, a *NativeActor) { r.Ticket = strings.Repeat("a", 64) }},
+		{"session", func(r *DataRequest, a *NativeActor) { a.sessionRef = strings.Repeat("a", 64) }},
+		{"instance", func(r *DataRequest, a *NativeActor) { a.account.Principal.InstanceRef = strings.Repeat("a", 64) }},
+		{"unknown actor", func(r *DataRequest, a *NativeActor) { *a = NativeActor{} }},
+	}
+	for _, m := range mutations {
+		t.Run(m.name, func(t *testing.T) {
+			tickets, actor, request, _ := deliveryFixture(t)
+			issued, code := tickets.issue(context.Background(), actor, request)
+			if code != "" {
+				t.Fatal(code)
+			}
+			badActor := actor
+			bad := issued
+			m.mutate(&bad, &badActor)
+			if _, code = tickets.consume(context.Background(), badActor, bad); code == "" {
+				t.Fatal("substitution accepted")
+			}
+			if _, code = tickets.consume(context.Background(), actor, issued); code != "" {
+				t.Fatal("rejection burned valid ticket", code)
+			}
+		})
+	}
+	tickets, actor, request, now := deliveryFixture(t)
+	unknown := actor
+	unknown.account.Principal.InstanceRef = ""
+	if _, code := tickets.issue(context.Background(), unknown, request); code == "" {
+		t.Fatal("unknown incarnation")
+	}
+	unknown = actor
+	unknown.account.Groups = nil
+	if _, code := tickets.issue(context.Background(), unknown, request); code == "" {
+		t.Fatal("unknown groups")
+	}
+	tickets.now = func() time.Time { return now.Add(NativeProofFreshness + time.Nanosecond) }
+	if _, code := tickets.issue(context.Background(), actor, request); code != ErrStale {
+		t.Fatal("stale native proof", code)
+	}
+}
+
+func TestOperationTicketsBoundsExpiryCancelAndClose(t *testing.T) {
+	tickets, actor, request, now := deliveryFixture(t)
+	bad := request
+	bad.Ticket = strings.Repeat("f", 64)
+	if _, code := tickets.issue(context.Background(), actor, bad); code != ErrInvalid {
+		t.Fatal("caller chose ticket", code)
+	}
+	issued, code := tickets.issue(context.Background(), actor, request)
+	if code != "" {
+		t.Fatal(code)
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	if _, code = tickets.consume(ctx, actor, issued); code != ErrCanceled {
+		t.Fatal(code)
+	}
+	tickets.now = func() time.Time { return now.Add(IntentTTL) }
+	actor.account.CheckedAt = now.Add(IntentTTL)
+	if _, code = tickets.consume(context.Background(), actor, issued); code != ErrExpired {
+		t.Fatal(code)
+	}
+	tickets.now = func() time.Time { return now }
+	actor.account.CheckedAt = now
+	for len(tickets.issued) < MaxReplayEntries {
+		if _, code = tickets.issue(context.Background(), actor, request); code != "" {
+			t.Fatal(code)
+		}
+	}
+	if _, code = tickets.issue(context.Background(), actor, request); code != ErrBusy {
+		t.Fatal("capacity evicted expired ticket", code)
+	}
+	tickets.close()
+	if _, code = tickets.issue(context.Background(), actor, request); code != ErrUnavailable {
+		t.Fatal(code)
+	}
+	var absent *operationTickets
+	if _, code = absent.consume(context.Background(), actor, issued); code != ErrUnavailable {
+		t.Fatal(code)
+	}
+	if _, code = newOperationTickets(Inventory{}, request.Epoch); code == "" {
+		t.Fatal("invalid inventory")
+	}
+}
+
+func TestOperationTicketsRandomFailureCollisionAndConcurrentUse(t *testing.T) {
+	tickets, actor, request, _ := deliveryFixture(t)
+	tickets.random = strings.NewReader("")
+	if _, code := tickets.issue(context.Background(), actor, request); code != ErrUnavailable {
+		t.Fatal(code)
+	}
+	tickets.random = strings.NewReader(strings.Repeat("x", 64))
+	issued, code := tickets.issue(context.Background(), actor, request)
+	if code != "" {
+		t.Fatal(code)
+	}
+	if _, code = tickets.issue(context.Background(), actor, request); code != ErrUnavailable {
+		t.Fatal("collision replaced ticket", code)
+	}
+	results := make(chan Code, 16)
+	var wg sync.WaitGroup
+	for i := 0; i < 16; i++ {
+		wg.Add(1)
+		go func() { defer wg.Done(); _, c := tickets.consume(context.Background(), actor, issued); results <- c }()
+	}
+	wg.Wait()
+	close(results)
+	success := 0
+	for c := range results {
+		if c == "" {
+			success++
+		} else if c != ErrReplay {
+			t.Fatal(c)
+		}
+	}
+	if success != 1 {
+		t.Fatal("single use", success)
+	}
+}
+
+func outputFixture(t *testing.T) (*outputHandoff, operationBinding, time.Time) {
+	t.Helper()
+	r, _, now := validRequestAndTicket(t)
+	h, c := newOutputHandoff(r.Inventory, r.Epoch)
+	if c != "" {
+		t.Fatal(c)
+	}
+	h.now = func() time.Time { return now }
+	b := operationBinding{r.Inventory, r.Epoch, r.OperationID, r.Nonce, r.GrantID, r.GrantRevision}
+	return h, b, now
+}
+
+func TestOutputHandoffExactBindingAndSingleUse(t *testing.T) {
+	h, b, _ := outputFixture(t)
+	writer, reader := net.Pipe()
+	defer reader.Close()
+	if c := h.register(b, writer); c != "" {
+		t.Fatal(c)
+	}
+	bad := b
+	bad.Nonce = strings.Repeat("a", 64)
+	if out, c := h.take(bad); c != ErrDenied || out != nil {
+		t.Fatal("substitution", c)
+	}
+	out, c := h.take(b)
+	if c != "" || out != writer {
+		t.Fatal(c)
+	}
+	defer out.Close()
+	if out, c := h.take(b); c != ErrReplay || out != nil {
+		t.Fatal(c)
+	}
+	h.close() // transferred endpoint belongs to S2; Close cannot steal it.
+	done := make(chan error, 1)
+	go func() { _, err := writer.Write([]byte("ok")); done <- err }()
+	reader.SetReadDeadline(time.Now().Add(time.Second))
+	buf := make([]byte, 2)
+	if _, err := io.ReadFull(reader, buf); err != nil || string(buf) != "ok" {
+		t.Fatal(err)
+	}
+	if err := <-done; err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestOutputHandoffUnknownExpiredDuplicateClosed(t *testing.T) {
+	for _, name := range []string{"expired", "duplicate", "closed", "invalid"} {
+		t.Run(name, func(t *testing.T) {
+			h, b, now := outputFixture(t)
+			w, r := net.Pipe()
+			defer r.Close()
+			switch name {
+			case "expired":
+				if c := h.register(b, w); c != "" {
+					t.Fatal(c)
+				}
+				h.now = func() time.Time { return now.Add(BoundedTimeout) }
+				if out, c := h.take(b); c != ErrExpired || out != nil {
+					t.Fatal(c)
+				}
+			case "duplicate":
+				old, oldReader := net.Pipe()
+				defer oldReader.Close()
+				defer h.close()
+				if c := h.register(b, old); c != "" {
+					t.Fatal(c)
+				}
+				if c := h.register(b, w); c != ErrReplay {
+					t.Fatal(c)
+				}
+			case "closed":
+				h.close()
+				if c := h.register(b, w); c != ErrUnavailable {
+					t.Fatal(c)
+				}
+			case "invalid":
+				b.Epoch = ""
+				if c := h.register(b, w); c == "" {
+					t.Fatal("invalid binding accepted")
+				}
+			}
+			r.SetReadDeadline(time.Now().Add(time.Second))
+			if _, err := r.Read(make([]byte, 1)); err != io.EOF {
+				t.Fatal("refused connection leaked", err)
+			}
+		})
+	}
+	h, b, _ := outputFixture(t)
+	if out, c := h.take(b); c != ErrDenied || out != nil {
+		t.Fatal("unknown output", c)
+	}
+	if c := h.register(b, nil); c != ErrInvalid {
+		t.Fatal("nil transport", c)
+	}
+	var absent *outputHandoff
+	if out, c := absent.take(b); c != ErrUnavailable || out != nil {
+		t.Fatal(c)
+	}
+}
+
+func TestOutputHandoffCapAndClosePending(t *testing.T) {
+	h, b, _ := outputFixture(t)
+	for i := 0; i < MaxReplayEntries; i++ {
+		x := b
+		x.OperationID = fmt.Sprintf("%064x", i+100)
+		w, r := net.Pipe()
+		r.Close()
+		if c := h.register(x, w); c != "" {
+			t.Fatal(c)
+		}
+		out, c := h.take(x)
+		if c != "" {
+			t.Fatal(c)
+		}
+		out.Close()
+	}
+	w, r := net.Pipe()
+	defer r.Close()
+	if c := h.register(b, w); c != ErrBusy {
+		t.Fatal("history evicted", c)
+	}
+	h, b, _ = outputFixture(t)
+	w, r = net.Pipe()
+	defer r.Close()
+	if c := h.register(b, w); c != "" {
+		t.Fatal(c)
+	}
+	h.close()
+	h.close()
+	if out, c := h.take(b); c != ErrUnavailable || out != nil {
+		t.Fatal(c)
+	}
+	r.SetReadDeadline(time.Now().Add(time.Second))
+	if _, err := r.Read(make([]byte, 1)); err != io.EOF {
+		t.Fatal(err)
+	}
+}

package/templates/native-go/backend/internal/helper/grant_operation_contract.go

@@ -0,0 +1,47 @@
+package helper
+
+import (
+	"context"
+	"net"
+)
+
+// Root-only S1/S5 seam. It must establish App authorization, native ACL,
+// grant-owner/scope continuity and a server-issued single-use ticket bound to
+// the COMPLETE decoded control and actor/session. It is not installed by S3;
+// nil always refuses work. No caller continuity/actor/admin fields are accepted.
+type GrantOperationValidator interface {
+	ValidateOperation(context.Context, NativeActor, DataRequest, Grant) (GrantUseValidation, Code)
+}
+
+type GrantUseValidation struct {
+	Binding    ContinuityBinding
+	Continuous bool
+	Ticket     TicketBinding
+	root       readOnlyRootWitness // trusted in-memory epoch pin; never caller JSON
+}
+
+// Fixed internal supervisor services. There is no package/plugin injection or
+// caller executable. S3 production leaves unproved native/ACL adapters nil.
+type supervisorGrantServices struct {
+	writes       writeGates
+	writeIntents writeIntentStore
+	native       *NativeProvider
+	consent      ConsentValidator
+	operations   GrantOperationValidator
+	output       func(operationBinding) (net.Conn, Code)
+}
+
+// GrantDrainProof is S2's bounded receipt for one grant. Reaped counts require
+// actual owned-child Wait4 AND stopped relay/closed private descriptors. Bytes
+// count admitted effects; they do not assert rollback or bytes already sent.
+type GrantDrainProof struct {
+	Key                 GrantDrainKey `json:"key"`
+	Started             uint64        `json:"started"`
+	Reaped              uint64        `json:"reaped"`
+	WriteOperations     uint64        `json:"writeOperations,omitempty"`
+	BytesWritten        uint64        `json:"bytesWritten,omitempty"`
+	WriteEffectsUnknown bool          `json:"writeEffectsUnknown,omitempty"`
+	PublishedOperations uint64        `json:"publishedOperations,omitempty"`
+	CommittedOperations uint64        `json:"committedOperations,omitempty"`
+	AdmittedBytes       uint64        `json:"admittedBytes"`
+}