refactor(counter): keep domain as the sequence name

## Summary

### Why?

Queue-prefixed resource IDs contain URL separators and duplicate scope already carried by the queue, route, and typed field. Resource IDs should remain flexible string contracts rather than forcing Go, protobuf, or SQL resource fields to integer types.

### What?

- Store canonical positive decimal strings such as "42" for SubmitQueue request IDs, SubmitQueue batch IDs, and Stovepipe request IDs while keeping resource and reference fields as strings and VARCHAR columns.
- Keep the existing counter schema and (queue, domain) key unchanged; domain names the sequence (request or batch), not an application. SubmitQueue and Stovepipe have separate storage backends, so no ownerDomain dimension is introduced. Stovepipe uses the durable MySQL counter.
- Put the shared formatting, validation, and numeric comparison helpers in platform/base/id. Keep domain naming consistent across the counter contract, implementation, callers, mocks, tests, and docs.
- Validate direct resource-ID inputs and retain the queue-scoped test fixes and cross-queue ID regression coverage from the prior review pass. Provider IDs, URIs, hashes, and derived event IDs keep their contracts.

## Test Plan

- ✅ make build
- ✅ make test (129 targets passed)
- ✅ make check-gazelle, make check-mocks, make check-tidy, and make lint
- ✅ git diff --check
- ✅ git diff --quiet main -- ':(glob)**/schema/*.sql' (no schema differences from main)
- ✅ Rebased onto main (`6884180e`), preserving the RFC → implementation stack and all seven commits. Runtime code is unchanged by the RFC table update.
- ✅ Fresh MySQL counter integration run with test-result caching disabled.
- ✅ The preceding comment pass also ran SubmitQueue gateway integration, Stovepipe integration, and Stovepipe e2e successfully (4/4 targets including the counter suite).
- ⚠️ aifx verify could not complete its monorepo coverage, generic Go lint, and UReview API checks; repository-native checks above passed.

Author: behinddwalls

doc/rfc/scoped-resource-ids.md

@@ -2,23 +2,23 @@
 
 ## Decision
 
-A generated resource ID is the canonical decimal string for a positive value returned by a durable counter scoped to `(queue, resource type)` within an application's storage.
+A generated resource ID is the canonical decimal string for a positive value returned by a durable counter scoped to `(queue, domain)` within an application's storage.
 
-SubmitQueue and Stovepipe use separate storage backends. Resource type is `request` or `batch`; there is no additional application-domain key or schema change.
+The counter domain names the sequence (`request` or `batch`), not the application. SubmitQueue and Stovepipe use separate storage backends; there is no additional application-domain key or schema change.
 
 | Resource | Current ID | Proposed ID | Identity within the application |
 |---|---:|---:|---|
 | SubmitQueue request | `demo-queue/42` | `"42"` | `(demo-queue, request, "42")` |
 | SubmitQueue batch | `demo-queue/batch/7` | `"7"` | `(demo-queue, batch, "7")` |
 | Stovepipe request | `request/monorepo/main/42` | `"42"` | `(monorepo/main, request, "42")` |
 
-The decimal ID is unique only within its scope. The same value may appear in another queue, resource type, or application. APIs and messages therefore carry the queue separately; their typed field or message type supplies the resource type.
+The decimal ID is unique only within its scope. The same value may appear in another queue, counter domain, or application. APIs and messages therefore carry the queue separately; their typed field or message type supplies the counter domain.
 
 Do not embed scope into the ID. Forms such as `demo-queue/42`, `demo-queue/batch/7`, `request.42`, and ARN-like resource names are not stored or accepted as IDs.
 
 ## Counter
 
-The counter backend persists one high-water mark per `(queue, resource type)`. MySQL keeps its existing `(queue, domain)` primary key; `domain` stores the resource type. For example:
+The counter backend persists one high-water mark per `(queue, domain)`. MySQL keeps its existing schema and primary key. For example:
 
 ```text
 (demo-queue, request) -> 42
@@ -61,7 +61,7 @@ Both columns use the same queue prefix for comparison. The before batch/change r
 
 ## Rejected alternatives
 
-- **Queue or resource-type prefixes:** duplicate explicit context, lengthen keys, require parsing, and introduce URL separators.
+- **Queue or domain prefixes:** duplicate explicit context, lengthen keys, require parsing, and introduce URL separators.
 - **ARN-like names:** solve global lookup, which current APIs neither provide nor require.
 - **UUIDs or a global counter:** provide global uniqueness at the cost of unnecessary encoding or coordination.
 - **Integer resource fields:** couple the persisted and wire contracts to the current counter representation without adding identity semantics.

platform/extension/counter/README.md

@@ -1,8 +1,8 @@
 # Counter
 
-Vendor-agnostic interface for atomic sequential number generation, scoped by queue and resource type.
+Vendor-agnostic interface for atomic sequential number generation, scoped by queue and domain.
 
-SubmitQueue and Stovepipe use separate storage backends. The existing MySQL `domain` column names the resource type (`request` or `batch`); the schema and `(queue, domain)` key remain unchanged.
+The domain names a counter sequence (`request` or `batch`), not an application. SubmitQueue and Stovepipe use separate storage backends; the existing MySQL schema and `(queue, domain)` key remain unchanged.
 
 ## Interface
 
@@ -12,12 +12,12 @@ Resolves the Counter bound to one queue. The host wiring decides which backend s
 
 ### Counter
 
-Generates unique, sequential values scoped to a resource type within the bound queue.
+Generates unique, sequential values scoped to a domain within the bound queue.
 
-- **resource type**: A string key naming a sequence within the queue (max 255 characters). Each `(queue, resource type)` pair maintains its own independent sequence.
-- **Next**: Atomically increments and returns the next value. The first call for a new resource type returns 1. Safe for concurrent use; values are unique but ordering is not guaranteed.
+- **domain**: A string key naming a sequence within the queue (max 255 characters). Each `(queue, domain)` pair maintains its own independent sequence.
+- **Next**: Atomically increments and returns the next value. The first call for a new domain returns 1. Safe for concurrent use; values are unique but ordering is not guaranteed.
 
-The resource type is a sequence name, not an ID prefix. Callers pass `"request"` or `"batch"`; the returned number is formatted as a decimal string without embedding any scope.
+The domain is not an ID prefix. Callers pass `"request"` or `"batch"`; the returned number is formatted as a decimal string without embedding any scope.
 
 ## Usage
 

platform/extension/counter/counter.go

@@ -37,14 +37,15 @@ type Factory interface {
 	For(config Config) (Counter, error)
 }
 
-// Counter provides atomic sequential number generation for a resource type within
+// Counter provides atomic sequential number generation for a domain within
 // the queue the instance is bound to.
-// Each call to Next returns the next value in the sequence for the specified resource type.
-// The value is unique within the (queue, resource type) pair.
+// Each call to Next returns the next value in the sequence for the specified domain.
+// The value is unique within the (queue, domain) pair.
+// A domain names a sequence, such as "request" or "batch", not an application.
 type Counter interface {
-	// Next atomically increments the counter for the given resource type and returns the new value.
-	// The first call for a new resource type returns 1.
-	// The implementation should support resource types up to 255 bytes.
+	// Next atomically increments the counter for the given domain and returns the new value.
+	// The first call for a new domain returns 1.
+	// The implementation should support domains up to 255 bytes.
 	// The function is safe to be called concurrently and will give unique results, but the order of the values is not guaranteed.
-	Next(ctx context.Context, resourceType string) (int64, error)
+	Next(ctx context.Context, domain string) (int64, error)
 }

platform/extension/counter/mock/counter_mock.go

@@ -37,26 +37,26 @@ func NewCounter(db *sql.DB, scope tally.Scope, queue string) counter.Counter {
 	return &mysqlCounter{db: db, scope: scope, queue: queue}
 }
 
-// Next atomically increments the counter for the given resource type within the bound scope
+// Next atomically increments the counter for the given domain within the bound scope
 // and returns the new value.
 // Uses MySQL's LAST_INSERT_ID() to set the value atomically and read the incremented value.
-func (c *mysqlCounter) Next(ctx context.Context, resourceType string) (ret int64, retErr error) {
+func (c *mysqlCounter) Next(ctx context.Context, domain string) (ret int64, retErr error) {
 	op := metrics.Begin(c.scope, "next", metrics.StorageLatencyBuckets)
 	defer func() { op.Complete(retErr) }()
 	result, err := c.db.ExecContext(ctx,
 		"INSERT INTO counter (queue, domain, value) VALUES (?, ?, LAST_INSERT_ID(1)) ON DUPLICATE KEY UPDATE value = LAST_INSERT_ID(value + 1)",
-		c.queue, resourceType,
+		c.queue, domain,
 	)
 	if err != nil {
-		return 0, fmt.Errorf("failed to increment counter for queue=%s resource_type=%s: %w", c.queue, resourceType, err)
+		return 0, fmt.Errorf("failed to increment counter for queue=%s domain=%s: %w", c.queue, domain, err)
 	}
 
 	value, err := result.LastInsertId()
 	if err != nil {
-		return 0, fmt.Errorf("failed to get counter value for queue=%s resource_type=%s: %w", c.queue, resourceType, err)
+		return 0, fmt.Errorf("failed to get counter value for queue=%s domain=%s: %w", c.queue, domain, err)
 	}
 	if value <= 0 {
-		return 0, fmt.Errorf("counter returned non-positive value for queue=%s resource_type=%s", c.queue, resourceType)
+		return 0, fmt.Errorf("counter returned non-positive value for queue=%s domain=%s", c.queue, domain)
 	}
 
 	return value, nil

platform/extension/counter/mysql/counter.go

@@ -33,8 +33,8 @@ import (
 	"go.uber.org/zap"
 )
 
-// counterResourceTypeRequest names the per-queue sequence that mints request IDs.
-const counterResourceTypeRequest = "request"
+// counterDomainRequest names the per-queue sequence that mints request IDs.
+const counterDomainRequest = "request"
 
 // IngestController handles ingest business logic for stovepipe: it admits a queue's newly
 // observed commit into the validation pipeline.
@@ -187,7 +187,7 @@ func (c *IngestController) resolveID(ctx context.Context, store storage.Storage,
 	if err != nil {
 		return "", fmt.Errorf("failed to resolve counter for queue=%s: %w", queue, err)
 	}
-	seq, err := queueCounter.Next(ctx, counterResourceTypeRequest)
+	seq, err := queueCounter.Next(ctx, counterDomainRequest)
 	if err != nil {
 		return "", fmt.Errorf("failed to generate request ID for queue=%s: %w", queue, err)
 	}

stovepipe/controller/ingest.go

@@ -174,7 +174,7 @@ func TestIngestController_Ingest(t *testing.T) {
 			setup: func(m ingestMocks) {
 				expectResolve(m)
 				m.uriStore.EXPECT().GetIDByURI(gomock.Any(), testURI).Return("", storage.ErrNotFound)
-				m.counter.EXPECT().Next(gomock.Any(), counterResourceTypeRequest).Return(int64(7), nil)
+				m.counter.EXPECT().Next(gomock.Any(), counterDomainRequest).Return(int64(7), nil)
 				m.uriStore.EXPECT().Create(gomock.Any(), testURI, "7").Return(nil)
 				m.reqStore.EXPECT().Get(gomock.Any(), "7").Return(entity.Request{}, storage.ErrNotFound)
 				m.reqStore.EXPECT().Create(gomock.Any(), gomock.Any()).Return(nil)
@@ -217,7 +217,7 @@ func TestIngestController_Ingest(t *testing.T) {
 			setup: func(m ingestMocks) {
 				expectResolve(m)
 				m.uriStore.EXPECT().GetIDByURI(gomock.Any(), testURI).Return("", storage.ErrNotFound)
-				m.counter.EXPECT().Next(gomock.Any(), counterResourceTypeRequest).Return(int64(7), nil)
+				m.counter.EXPECT().Next(gomock.Any(), counterDomainRequest).Return(int64(7), nil)
 				m.uriStore.EXPECT().Create(gomock.Any(), testURI, "7").Return(storage.ErrAlreadyExists)
 				m.uriStore.EXPECT().GetIDByURI(gomock.Any(), testURI).Return("3", nil)
 				m.reqStore.EXPECT().Get(gomock.Any(), "3").Return(acceptedRequest("3"), nil)

stovepipe/controller/ingest_test.go

@@ -63,8 +63,8 @@ func IsUnrecognizedQueue(err error) bool {
 	return errors.As(err, &target)
 }
 
-// counterResourceTypeRequest names the per-queue sequence that mints request IDs.
-const counterResourceTypeRequest = "request"
+// counterDomainRequest names the per-queue sequence that mints request IDs.
+const counterDomainRequest = "request"
 
 // LandController handles land business logic for the gateway
 type LandController interface {
@@ -131,7 +131,7 @@ func (c *landController) Land(ctx context.Context, req entity.LandRequest) (resu
 	if err != nil {
 		return entity.LandResult{}, fmt.Errorf("failed to resolve counter for queue=%s: %w", queue, err)
 	}
-	seq, err := queueCounter.Next(ctx, counterResourceTypeRequest)
+	seq, err := queueCounter.Next(ctx, counterDomainRequest)
 	if err != nil {
 		return entity.LandResult{}, fmt.Errorf("failed to generate request ID for queue=%s: %w", queue, err)
 	}

submitqueue/gateway/controller/land.go

@@ -157,17 +157,17 @@ func TestLand_ReturnsErrorOnNonPositiveCounterValue(t *testing.T) {
 }
 
 // TestLand_ResolvesCounterForRequestQueue pins that the queue reaches the counter
-// through the factory binding rather than through the resource-type string: the value is a
+// through the factory binding rather than through the domain name: the value is a
 // bare sequence name, and the sqid is the decimal counter value.
 func TestLand_ResolvesCounterForRequestQueue(t *testing.T) {
-	var capturedResourceType, capturedQueue string
+	var capturedDomain, capturedQueue string
 
 	ctrl := gomock.NewController(t)
 
 	cnt := countermock.NewMockCounter(ctrl)
 	cnt.EXPECT().Next(gomock.Any(), gomock.Any()).DoAndReturn(
-		func(ctx context.Context, resourceType string) (int64, error) {
-			capturedResourceType = resourceType
+		func(ctx context.Context, domain string) (int64, error) {
+			capturedDomain = domain
 			return 1, nil
 		},
 	)
@@ -186,7 +186,7 @@ func TestLand_ResolvesCounterForRequestQueue(t *testing.T) {
 	result, err := controller.Land(ctx, testLandRequest("my-queue"))
 
 	require.NoError(t, err)
-	assert.Equal(t, "request", capturedResourceType, "the resource type is a sequence name, not a queue-qualified key")
+	assert.Equal(t, "request", capturedDomain, "the domain is a sequence name, not a queue-qualified key")
 	assert.Equal(t, "my-queue", capturedQueue, "the queue reaches the counter through the factory binding")
 	assert.Equal(t, "1", result.ID)
 }

submitqueue/gateway/controller/land_test.go

@@ -52,8 +52,8 @@ var _ consumer.Controller = (*Controller)(nil)
 
 const opName = "process"
 
-// counterResourceTypeBatch names the per-queue sequence that mints batch IDs.
-const counterResourceTypeBatch = "batch"
+// counterDomainBatch names the per-queue sequence that mints batch IDs.
+const counterDomainBatch = "batch"
 
 // NewController creates a new batch controller for the orchestrator.
 func NewController(
@@ -143,7 +143,7 @@ func (c *Controller) Process(ctx context.Context, delivery consumer.Delivery) er
 		metrics.NamedCounter(c.metricsScope, opName, "counter_errors", 1)
 		return fmt.Errorf("failed to resolve counter for queue=%s: %w", request.Queue, err)
 	}
-	seq, err := queueCounter.Next(ctx, counterResourceTypeBatch)
+	seq, err := queueCounter.Next(ctx, counterDomainBatch)
 	if err != nil {
 		metrics.NamedCounter(c.metricsScope, opName, "counter_errors", 1)
 		return fmt.Errorf("failed to generate batch ID for queue=%s: %w", request.Queue, err)