Remove plugin data query projection

platform/api/routes.md

@@ -24,6 +24,8 @@ All routes use JSON request and response bodies. Collection routes support `GET`
 | Artifacts | `GET /api/v1/artifacts`, `POST /api/v1/artifacts` | `GET /api/v1/artifacts/{id}`, `POST /api/v1/artifacts/{id}/download`, `GET /api/v1/artifacts/{id}/content` | `ArtifactCreateRequest`, `ArtifactResponse`, `ArtifactListResponse`, `ArtifactDownloadReferenceResponse`, `ArtifactContentRequest` |
 | Log streams | `GET /api/v1/log-streams`, `POST /api/v1/log-streams` | `GET /api/v1/log-streams/{id}` | `LogStreamCreateRequest`, `LogStreamResponse`, `LogStreamListResponse` |
 
+Plugin-owned data is an independent, server-scoped plugin store. It is not a projection of the game-server database and never aliases platform user/auth storage.
+
 Client Manager lifecycle routes are grouped under the server instance and return only the safe installation projection: `GET /api/v1/server-instances/{id}/client-managers`, `GET .../{profileKey}`, and typed `POST` routes for `deploy`, `control`, `update`, `retry`, `revoke-session`, and confirmed `uninstall`. Component-only `POST /api/v1/client-managers/register` and `/heartbeat` use the separate signed component identity/session contract. Run-only input/chunk routes are fenced by the active Run job lease. None of these DTOs return raw component keys, bearer sessions, secret refs/values, host paths, PIDs, sockets, or endpoint addresses.
 
 ## Implemented Query Filters

platform/domain/game_client_bridge.go

@@ -44,19 +44,6 @@ type GameClientBridgeQueryTemplateDeclaration struct {
 	MaxRows             int
 	TimeoutSeconds      int
 	PollIntervalSeconds int
-	RowTarget           *PluginDataRowTargetDeclaration
-}
-
-const (
-	PluginDataRowWriteModeMerge   = "merge"
-	PluginDataRowWriteModeReplace = "replace"
-)
-
-type PluginDataRowTargetDeclaration struct {
-	Collection     string
-	UpsertKeys     []string
-	ColumnMappings map[string]string
-	WriteMode      string
 }
 
 type GameClientBridgeLogProjectionStepDeclaration struct {
@@ -407,12 +394,6 @@ func CopyGameClientBridgeManifest(value GameClientBridgeManifest) GameClientBrid
 	value.Commands = append([]GameClientBridgeCommandDeclaration(nil), value.Commands...)
 	value.Snapshots = append([]GameClientBridgeSnapshotDeclaration(nil), value.Snapshots...)
 	value.QueryTemplates = append([]GameClientBridgeQueryTemplateDeclaration(nil), value.QueryTemplates...)
-	for index := range value.QueryTemplates {
-		if value.QueryTemplates[index].RowTarget != nil {
-			copy := CopyPluginDataRowTargetDeclaration(*value.QueryTemplates[index].RowTarget)
-			value.QueryTemplates[index].RowTarget = &copy
-		}
-	}
 	value.LogProjections = append([]GameClientBridgeLogProjectionDeclaration(nil), value.LogProjections...)
 	for index := range value.LogProjections {
 		value.LogProjections[index] = CopyGameClientBridgeLogProjectionDeclaration(value.LogProjections[index])
@@ -438,12 +419,6 @@ func CopyGameClientBridgeManifest(value GameClientBridgeManifest) GameClientBrid
 	return value
 }
 
-func CopyPluginDataRowTargetDeclaration(value PluginDataRowTargetDeclaration) PluginDataRowTargetDeclaration {
-	value.UpsertKeys = CopyStringSlice(value.UpsertKeys)
-	value.ColumnMappings = CopyStringMap(value.ColumnMappings)
-	return value
-}
-
 func CopyGameClientBridgeLogProjectionDeclaration(value GameClientBridgeLogProjectionDeclaration) GameClientBridgeLogProjectionDeclaration {
 	value.StreamKeys = CopyStringSlice(value.StreamKeys)
 	value.Steps = append([]GameClientBridgeLogProjectionStepDeclaration(nil), value.Steps...)

platform/domain/game_client_bridge_test.go

@@ -4,7 +4,7 @@ import "testing"
 
 func TestCopyGameClientBridgeDeclarationsCopiesQueryTemplateSlices(t *testing.T) {
 	manifest := GameClientBridgeManifest{
-		QueryTemplates: []GameClientBridgeQueryTemplateDeclaration{{Key: "player.lookup", PollIntervalSeconds: 3, RowTarget: &PluginDataRowTargetDeclaration{Collection: "users", UpsertKeys: []string{"userId"}, ColumnMappings: map[string]string{"userId": "user_id"}, WriteMode: PluginDataRowWriteModeMerge}}},
+		QueryTemplates: []GameClientBridgeQueryTemplateDeclaration{{Key: "player.lookup", PollIntervalSeconds: 3, SQLRef: "sql/player-lookup.sql"}},
 		LogProjections: []GameClientBridgeLogProjectionDeclaration{{
 			Key: "player.login", StreamKeys: []string{"process.stdout"}, Steps: []GameClientBridgeLogProjectionStepDeclaration{{Pattern: `Player (?<slot>\d+)`}}, CorrelationFields: []string{"slot"}, MaxInterveningLines: 8,
 			Target:   GameClientBridgeLogProjectionTargetDeclaration{Collection: "users", UpsertKeys: []string{"steamId"}, CaptureMappings: map[string]string{"steamId": "steamId"}, FixedValues: map[string]string{"source": "stdout"}, ObservedAtField: "lastLoginAt"},
@@ -15,14 +15,13 @@ func TestCopyGameClientBridgeDeclarationsCopiesQueryTemplateSlices(t *testing.T)
 	}
 	manifestCopy := CopyGameClientBridgeManifest(manifest)
 	manifestCopy.QueryTemplates[0].Key = "mutated"
-	manifestCopy.QueryTemplates[0].RowTarget.ColumnMappings["userId"] = "mutated"
 	manifestCopy.LogProjections[0].StreamKeys[0] = "mutated"
 	manifestCopy.LogProjections[0].Target.CaptureMappings["steamId"] = "mutated"
 	manifestCopy.LogProjections[0].Presence.ActivityTarget.CaptureMappings["steamId"] = "mutated"
 	manifestCopy.DataPacks[0].LogParserRefs[0] = "mutated"
 	manifestCopy.DataPacks[0].DataRefs[0] = "mutated"
 	manifestCopy.Pages[0].QueryTemplateKeys[0] = "mutated"
-	if manifest.QueryTemplates[0].Key != "player.lookup" || manifest.QueryTemplates[0].RowTarget.ColumnMappings["userId"] != "user_id" || manifest.LogProjections[0].StreamKeys[0] != "process.stdout" || manifest.LogProjections[0].Target.CaptureMappings["steamId"] != "steamId" || manifest.LogProjections[0].Presence.ActivityTarget.CaptureMappings["steamId"] != "steamId" || manifest.DataPacks[0].LogParserRefs[0] != "logs.json" || manifest.DataPacks[0].DataRefs[0] != "data.json" || manifest.Pages[0].QueryTemplateKeys[0] != "player.lookup" {
+	if manifest.QueryTemplates[0].Key != "player.lookup" || manifest.QueryTemplates[0].SQLRef != "sql/player-lookup.sql" || manifest.LogProjections[0].StreamKeys[0] != "process.stdout" || manifest.LogProjections[0].Target.CaptureMappings["steamId"] != "steamId" || manifest.LogProjections[0].Presence.ActivityTarget.CaptureMappings["steamId"] != "steamId" || manifest.DataPacks[0].LogParserRefs[0] != "logs.json" || manifest.DataPacks[0].DataRefs[0] != "data.json" || manifest.Pages[0].QueryTemplateKeys[0] != "player.lookup" {
 		t.Fatalf("manifest copy aliases query template declarations: source=%#v copy=%#v", manifest, manifestCopy)
 	}
 

platform/domain/plugin_data.go

@@ -2,8 +2,9 @@ package domain
 
 import "time"
 
-// PluginDataRecord is an opaque plugin-owned platform record. Platform scopes
-// it but does not interpret the collection name or payload fields.
+// PluginDataRecord is an opaque plugin-owned, server-scoped platform record.
+// It is separate from platform users/auth sessions and from game-server data;
+// Platform scopes it but does not interpret collection names or payload fields.
 type PluginDataRecord struct {
 	ID               string
 	PluginID         string

platform/dto/resources.go

@@ -279,26 +279,18 @@ type GameClientBridgeSnapshotDeclarationBody struct {
 }
 
 type GameClientBridgeQueryTemplateDeclarationBody struct {
-	Key                 string                              `json:"key"`
-	Title               string                              `json:"title"`
-	Permission          string                              `json:"permission"`
-	Engine              string                              `json:"engine"`
-	TransportKey        string                              `json:"transportKey"`
-	TargetKey           string                              `json:"targetKey"`
-	ParameterSchemaRef  string                              `json:"parameterSchemaRef"`
-	ResultSchemaRef     string                              `json:"resultSchemaRef"`
-	SQLRef              string                              `json:"sqlRef,omitempty"`
-	MaxRows             int                                 `json:"maxRows"`
-	TimeoutSeconds      int                                 `json:"timeoutSeconds"`
-	PollIntervalSeconds int                                 `json:"pollIntervalSeconds"`
-	RowTarget           *PluginDataRowTargetDeclarationBody `json:"rowTarget,omitempty"`
-}
-
-type PluginDataRowTargetDeclarationBody struct {
-	Collection     string            `json:"collection"`
-	UpsertKeys     []string          `json:"upsertKeys"`
-	ColumnMappings map[string]string `json:"columnMappings"`
-	WriteMode      string            `json:"writeMode"`
+	Key                 string `json:"key"`
+	Title               string `json:"title"`
+	Permission          string `json:"permission"`
+	Engine              string `json:"engine"`
+	TransportKey        string `json:"transportKey"`
+	TargetKey           string `json:"targetKey"`
+	ParameterSchemaRef  string `json:"parameterSchemaRef"`
+	ResultSchemaRef     string `json:"resultSchemaRef"`
+	SQLRef              string `json:"sqlRef,omitempty"`
+	MaxRows             int    `json:"maxRows"`
+	TimeoutSeconds      int    `json:"timeoutSeconds"`
+	PollIntervalSeconds int    `json:"pollIntervalSeconds"`
 }
 
 type GameClientBridgeLogProjectionStepDeclarationBody struct {
@@ -1145,12 +1137,7 @@ func (body GameClientBridgeManifestBody) ToDomain() domain.GameClientBridgeManif
 	}
 	queryTemplates := make([]domain.GameClientBridgeQueryTemplateDeclaration, len(body.QueryTemplates))
 	for index, template := range body.QueryTemplates {
-		var rowTarget *domain.PluginDataRowTargetDeclaration
-		if template.RowTarget != nil {
-			value := domain.PluginDataRowTargetDeclaration{Collection: template.RowTarget.Collection, UpsertKeys: domain.CopyStringSlice(template.RowTarget.UpsertKeys), ColumnMappings: domain.CopyStringMap(template.RowTarget.ColumnMappings), WriteMode: template.RowTarget.WriteMode}
-			rowTarget = &value
-		}
-		queryTemplates[index] = domain.GameClientBridgeQueryTemplateDeclaration{Key: template.Key, Title: template.Title, Permission: template.Permission, Engine: template.Engine, TransportKey: template.TransportKey, TargetKey: template.TargetKey, ParameterSchemaRef: template.ParameterSchemaRef, ResultSchemaRef: template.ResultSchemaRef, SQLRef: template.SQLRef, MaxRows: template.MaxRows, TimeoutSeconds: template.TimeoutSeconds, PollIntervalSeconds: template.PollIntervalSeconds, RowTarget: rowTarget}
+		queryTemplates[index] = domain.GameClientBridgeQueryTemplateDeclaration{Key: template.Key, Title: template.Title, Permission: template.Permission, Engine: template.Engine, TransportKey: template.TransportKey, TargetKey: template.TargetKey, ParameterSchemaRef: template.ParameterSchemaRef, ResultSchemaRef: template.ResultSchemaRef, SQLRef: template.SQLRef, MaxRows: template.MaxRows, TimeoutSeconds: template.TimeoutSeconds, PollIntervalSeconds: template.PollIntervalSeconds}
 	}
 	logProjections := make([]domain.GameClientBridgeLogProjectionDeclaration, len(body.LogProjections))
 	for index, projection := range body.LogProjections {
@@ -1602,11 +1589,7 @@ func gameClientBridgeManifestFromDomain(value domain.GameClientBridgeManifest) G
 	}
 	queryTemplates := make([]GameClientBridgeQueryTemplateDeclarationBody, len(value.QueryTemplates))
 	for index, template := range value.QueryTemplates {
-		var rowTarget *PluginDataRowTargetDeclarationBody
-		if template.RowTarget != nil {
-			rowTarget = &PluginDataRowTargetDeclarationBody{Collection: template.RowTarget.Collection, UpsertKeys: domain.CopyStringSlice(template.RowTarget.UpsertKeys), ColumnMappings: domain.CopyStringMap(template.RowTarget.ColumnMappings), WriteMode: template.RowTarget.WriteMode}
-		}
-		queryTemplates[index] = GameClientBridgeQueryTemplateDeclarationBody{Key: template.Key, Title: template.Title, Permission: template.Permission, Engine: template.Engine, TransportKey: template.TransportKey, TargetKey: template.TargetKey, ParameterSchemaRef: template.ParameterSchemaRef, ResultSchemaRef: template.ResultSchemaRef, SQLRef: template.SQLRef, MaxRows: template.MaxRows, TimeoutSeconds: template.TimeoutSeconds, PollIntervalSeconds: template.PollIntervalSeconds, RowTarget: rowTarget}
+		queryTemplates[index] = GameClientBridgeQueryTemplateDeclarationBody{Key: template.Key, Title: template.Title, Permission: template.Permission, Engine: template.Engine, TransportKey: template.TransportKey, TargetKey: template.TargetKey, ParameterSchemaRef: template.ParameterSchemaRef, ResultSchemaRef: template.ResultSchemaRef, SQLRef: template.SQLRef, MaxRows: template.MaxRows, TimeoutSeconds: template.TimeoutSeconds, PollIntervalSeconds: template.PollIntervalSeconds}
 	}
 	logProjections := make([]GameClientBridgeLogProjectionDeclarationBody, len(value.LogProjections))
 	for index, projection := range value.LogProjections {

platform/dto/resources_test.go

@@ -137,7 +137,6 @@ func TestGameClientBridgeQueryTemplateDeclarationRoundTripIsSafe(t *testing.T) {
 		QueryTemplates: []GameClientBridgeQueryTemplateDeclarationBody{{
 			Key: "player.lookup", Title: "Player lookup", Permission: "server.game-client.read", Engine: "sqlite", TransportKey: "sqlite-db", TargetKey: "db/sqlite",
 			ParameterSchemaRef: "schemas/bridge/query/player-lookup.parameters.schema.json", ResultSchemaRef: "schemas/bridge/query/player-lookup.result.schema.json", SQLRef: "sql/player-lookup.sql", MaxRows: 50, TimeoutSeconds: 10, PollIntervalSeconds: 3,
-			RowTarget: &PluginDataRowTargetDeclarationBody{Collection: "users", UpsertKeys: []string{"userId"}, ColumnMappings: map[string]string{"userId": "user_id"}, WriteMode: "merge"},
 		}},
 		LogProjections: []GameClientBridgeLogProjectionDeclarationBody{{
 			Key: "player.login", StreamKeys: []string{"process.stdout"}, Steps: []GameClientBridgeLogProjectionStepDeclarationBody{{Pattern: `Player (?<slot>\d+)`}}, CorrelationFields: []string{"slot"}, MaxInterveningLines: 8,
@@ -151,14 +150,9 @@ func TestGameClientBridgeQueryTemplateDeclarationRoundTripIsSafe(t *testing.T) {
 	}
 
 	domainManifest := body.ToDomain()
-	if len(domainManifest.QueryTemplates) != 1 || domainManifest.QueryTemplates[0].SQLRef != "sql/player-lookup.sql" || domainManifest.QueryTemplates[0].PollIntervalSeconds != 3 || domainManifest.QueryTemplates[0].RowTarget.Collection != "users" || domainManifest.QueryTemplates[0].RowTarget.WriteMode != "merge" || len(domainManifest.LogProjections) != 1 || domainManifest.LogProjections[0].Presence.ActiveWindowSeconds != 600 || len(domainManifest.DataPacks) != 1 || domainManifest.DataPacks[0].DataRefs[0] != "data/items.json" || domainManifest.Pages[0].QueryTemplateKeys[0] != "player.lookup" {
+	if len(domainManifest.QueryTemplates) != 1 || domainManifest.QueryTemplates[0].SQLRef != "sql/player-lookup.sql" || domainManifest.QueryTemplates[0].PollIntervalSeconds != 3 || len(domainManifest.LogProjections) != 1 || domainManifest.LogProjections[0].Presence.ActiveWindowSeconds != 600 || len(domainManifest.DataPacks) != 1 || domainManifest.DataPacks[0].DataRefs[0] != "data/items.json" || domainManifest.Pages[0].QueryTemplateKeys[0] != "player.lookup" {
 		t.Fatalf("query template conversion lost declaration fields: %#v", domainManifest)
 	}
-	domainManifest.QueryTemplates[0].RowTarget.ColumnMappings["userId"] = "mutated"
-	if body.QueryTemplates[0].RowTarget.ColumnMappings["userId"] != "user_id" {
-		t.Fatal("query template row target aliases request DTO data")
-	}
-	domainManifest.QueryTemplates[0].RowTarget.ColumnMappings["userId"] = "user_id"
 	domainManifest.LogProjections[0].Target.CaptureMappings["steamId"] = "mutated"
 	if body.LogProjections[0].Target.CaptureMappings["steamId"] != "steamId" {
 		t.Fatal("log projection target aliases request DTO data")
@@ -193,7 +187,7 @@ func TestGameClientBridgeQueryTemplateDeclarationRoundTripIsSafe(t *testing.T) {
 	if err := json.Unmarshal(encoded, &projection); err != nil {
 		t.Fatalf("decode safe query template projection: %v", err)
 	}
-	expectedFields := []string{"key", "title", "permission", "engine", "transportKey", "targetKey", "parameterSchemaRef", "resultSchemaRef", "sqlRef", "maxRows", "timeoutSeconds", "pollIntervalSeconds", "rowTarget"}
+	expectedFields := []string{"key", "title", "permission", "engine", "transportKey", "targetKey", "parameterSchemaRef", "resultSchemaRef", "sqlRef", "maxRows", "timeoutSeconds", "pollIntervalSeconds"}
 	if len(projection) != len(expectedFields) {
 		t.Fatalf("query template projection contains unexpected fields: %s", encoded)
 	}

platform/service/job_channel.go

@@ -40,9 +40,6 @@ func (svc *CoreService) ClaimRunJob(claim domain.RunJobClaim) (domain.RunJobClai
 	if err := svc.sweepExpiredJobs(claim.RunEndpointID, stamp); err != nil {
 		return domain.RunJobClaimResult{}, err
 	}
-	if err := svc.scheduleDuePluginQueries(claim.RunEndpointID, claim.Capabilities, stamp); err != nil {
-		return domain.RunJobClaimResult{}, err
-	}
 	if claim.Capacity.MaxJobs > 0 && claim.Capacity.RunningJobs >= claim.Capacity.MaxJobs {
 		return emptyJobClaim(claim.RunEndpointID, stamp), nil
 	}
@@ -263,9 +260,6 @@ func (svc *CoreService) CompleteRunJob(result domain.RunJobResult) (domain.RunJo
 	if err := svc.validateDistributionBuildResult(job); err != nil {
 		return domain.RunJobResultResult{}, err
 	}
-	if err := svc.projectPluginDataJobResult(job); err != nil {
-		return domain.RunJobResultResult{}, err
-	}
 	if err := svc.updateScheduledJob(job); err != nil {
 		return domain.RunJobResultResult{}, err
 	}

platform/service/plugin_data_projection.go

@@ -1,126 +0,0 @@
-package service
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"sort"
-	"strings"
-
-	"browser.local/platform/domain"
-	"browser.local/platform/repo"
-)
-
-type pluginDataQueryResult struct {
-	Rows []map[string]any `json:"rows"`
-}
-
-func (svc *CoreService) projectPluginDataJobResult(job domain.Job) error {
-	if job.Capability != domain.JobCapabilityRemoteRunDBSQLiteQuery || job.State != domain.JobStateSucceeded {
-		return nil
-	}
-	templateKey := strings.TrimSpace(job.ExecutionInput.Inputs["templateKey"])
-	if templateKey == "" {
-		return nil
-	}
-	instance, err := svc.store.ServerInstances().Get(job.ServerInstanceID)
-	if err != nil {
-		return err
-	}
-	plugin, err := svc.store.GamePlugins().Get(instance.PluginID)
-	if err != nil {
-		return err
-	}
-	var template domain.GameClientBridgeQueryTemplateDeclaration
-	for _, candidate := range plugin.GameClientBridge.QueryTemplates {
-		if candidate.Key == templateKey {
-			template = candidate
-			break
-		}
-	}
-	if template.RowTarget == nil {
-		return nil
-	}
-	var result pluginDataQueryResult
-	if err := json.Unmarshal([]byte(job.ExecutionResult.Content), &result); err != nil {
-		return validationError("declared query result is not valid JSON")
-	}
-	mutationsByKey := make(map[string]domain.PluginDataMutation, len(result.Rows))
-	for _, row := range result.Rows {
-		value := make(map[string]any, len(template.RowTarget.ColumnMappings))
-		for destination, source := range template.RowTarget.ColumnMappings {
-			value[destination] = row[source]
-		}
-		key, err := pluginDataRowKey(value, template.RowTarget.UpsertKeys)
-		if err != nil {
-			return err
-		}
-		if template.RowTarget.WriteMode == domain.PluginDataRowWriteModeMerge {
-			existing, getErr := svc.store.PluginDataRecords().Get(pluginDataID(instance.ID, plugin.ID, template.RowTarget.Collection, key))
-			if getErr == nil {
-				value = mergePluginDataValues(existing.Value, value)
-			} else if !errors.Is(getErr, repo.ErrNotFound) {
-				return getErr
-			}
-		}
-		mutationsByKey[key] = domain.PluginDataMutation{Operation: domain.PluginDataMutationPut, Key: key, Value: value}
-	}
-	if template.RowTarget.WriteMode == domain.PluginDataRowWriteModeReplace {
-		existing, listErr := svc.store.PluginDataRecords().List(domain.PluginDataFilter{PluginID: plugin.ID, ServerInstanceID: instance.ID, Collection: template.RowTarget.Collection})
-		if listErr != nil {
-			return listErr
-		}
-		for _, record := range existing {
-			if _, present := mutationsByKey[record.Key]; !present {
-				mutationsByKey[record.Key] = domain.PluginDataMutation{Operation: domain.PluginDataMutationDelete, Key: record.Key}
-			}
-		}
-	}
-	if len(mutationsByKey) == 0 {
-		return nil
-	}
-	keys := make([]string, 0, len(mutationsByKey))
-	for key := range mutationsByKey {
-		keys = append(keys, key)
-	}
-	sort.Strings(keys)
-	mutations := make([]domain.PluginDataMutation, 0, len(keys))
-	for _, key := range keys {
-		mutations = append(mutations, mutationsByKey[key])
-	}
-	_, err = svc.applyPluginDataTransaction(domain.PluginDataTransaction{PluginID: plugin.ID, ServerInstanceID: instance.ID, Collection: template.RowTarget.Collection, Mutations: mutations})
-	return err
-}
-
-func mergePluginDataValues(existing, incoming map[string]any) map[string]any {
-	merged := domain.CopyGameClientBridgePayload(existing)
-	if merged == nil {
-		merged = make(map[string]any, len(incoming))
-	}
-	for key, value := range incoming {
-		merged[key] = value
-	}
-	return merged
-}
-
-func pluginDataRowKey(value map[string]any, keys []string) (string, error) {
-	parts := make([]string, len(keys))
-	for index, key := range keys {
-		item, exists := value[key]
-		if !exists || item == nil || strings.TrimSpace(fmt.Sprint(item)) == "" {
-			return "", validationError("declared query row is missing an upsert key")
-		}
-		encoded, err := json.Marshal(item)
-		if err != nil {
-			return "", validationError("declared query row upsert key is invalid")
-		}
-		parts[index] = string(encoded)
-	}
-	if len(parts) == 1 {
-		var key string
-		if err := json.Unmarshal([]byte(parts[0]), &key); err == nil {
-			return key, nil
-		}
-	}
-	return strings.Join(parts, "\x1f"), nil
-}

platform/service/plugin_data_rows.go

@@ -0,0 +1,42 @@
+package service
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"browser.local/platform/domain"
+)
+
+func mergePluginDataValues(existing, incoming map[string]any) map[string]any {
+	merged := domain.CopyGameClientBridgePayload(existing)
+	if merged == nil {
+		merged = make(map[string]any, len(incoming))
+	}
+	for key, value := range incoming {
+		merged[key] = value
+	}
+	return merged
+}
+
+func pluginDataRowKey(value map[string]any, keys []string) (string, error) {
+	parts := make([]string, len(keys))
+	for index, key := range keys {
+		item, exists := value[key]
+		if !exists || item == nil || strings.TrimSpace(fmt.Sprint(item)) == "" {
+			return "", validationError("declared plugin data row is missing an upsert key")
+		}
+		encoded, err := json.Marshal(item)
+		if err != nil {
+			return "", validationError("declared plugin data row upsert key is invalid")
+		}
+		parts[index] = string(encoded)
+	}
+	if len(parts) == 1 {
+		var key string
+		if err := json.Unmarshal([]byte(parts[0]), &key); err == nil {
+			return key, nil
+		}
+	}
+	return strings.Join(parts, "\x1f"), nil
+}

platform/service/plugin_data_schedule.go

@@ -1,92 +0,0 @@
-package service
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-	"time"
-
-	"browser.local/platform/domain"
-)
-
-func (svc *CoreService) scheduleDuePluginQueries(runEndpointID string, capabilities []string, stamp time.Time) error {
-	if !containsString(capabilities, domain.JobCapabilityRemoteRunDBSQLiteQuery) {
-		return nil
-	}
-	instances, err := svc.store.ServerInstances().List(domain.ServerInstanceFilter{RunEndpointID: runEndpointID})
-	if err != nil {
-		return err
-	}
-	jobs, err := svc.store.Jobs().List(domain.JobFilter{RunEndpointID: runEndpointID})
-	if err != nil {
-		return err
-	}
-	for _, instance := range instances {
-		if instance.State == domain.ServerInstanceStateDeleted {
-			continue
-		}
-		plugin, getErr := svc.store.GamePlugins().Get(instance.PluginID)
-		if getErr != nil {
-			return getErr
-		}
-		for _, template := range plugin.GameClientBridge.QueryTemplates {
-			if template.PollIntervalSeconds <= 0 || template.RowTarget == nil || strings.TrimSpace(template.SQLRef) == "" {
-				continue
-			}
-			if !pluginQueryTemplateDue(jobs, instance.ID, template.Key, time.Duration(template.PollIntervalSeconds)*time.Second, stamp) {
-				continue
-			}
-			bucket := stamp.Unix() / int64(template.PollIntervalSeconds)
-			idempotencyKey := fmt.Sprintf("plugin-query:%s:%s:%d", instance.ID, template.Key, bucket)
-			job := domain.Job{
-				ID:               jobIDFromParts("job-plugin-query", instance.ID, idempotencyKey),
-				ServerInstanceID: instance.ID,
-				RunEndpointID:    runEndpointID,
-				Capability:       domain.JobCapabilityRemoteRunDBSQLiteQuery,
-				TargetKey:        template.TargetKey,
-				InputRef:         "input://plugin-query/" + template.Key,
-				IdempotencyKey:   idempotencyKey,
-				Progress:         domain.JobProgress{Percent: 0, Message: "declared automatic plugin query queued"},
-				RetryPolicy:      domain.JobRetryPolicy{MaxAttempts: 1, InitialBackoffSeconds: 1, MaxBackoffSeconds: 1},
-				ExecutionInput: domain.JobExecutionInput{
-					WorkspaceScope:    svc.runtimeProfileScope(instance.ID),
-					RemoteAdapterKey:  template.TransportKey,
-					RemoteAdapterKind: string(domain.RemoteAdapterDatabase),
-					TimeoutSeconds:    template.TimeoutSeconds,
-					Inputs: map[string]string{
-						"templateKey": template.Key,
-						"sqlRef":      template.SQLRef,
-						"maxRows":     strconv.Itoa(template.MaxRows),
-						"limit":       strconv.Itoa(template.MaxRows),
-					},
-				},
-			}
-			created, createErr := svc.CreateJob(job)
-			if createErr != nil {
-				return createErr
-			}
-			jobs = append(jobs, created)
-		}
-	}
-	return nil
-}
-
-func pluginQueryTemplateDue(jobs []domain.Job, serverInstanceID, templateKey string, interval time.Duration, stamp time.Time) bool {
-	var latest time.Time
-	for _, job := range jobs {
-		if job.ServerInstanceID != serverInstanceID || job.Capability != domain.JobCapabilityRemoteRunDBSQLiteQuery || job.ExecutionInput.Inputs["templateKey"] != templateKey {
-			continue
-		}
-		if !isTerminalJobState(job.State) {
-			return false
-		}
-		attemptedAt := job.TerminalAt
-		if attemptedAt.IsZero() {
-			attemptedAt = job.UpdatedAt
-		}
-		if attemptedAt.After(latest) {
-			latest = attemptedAt
-		}
-	}
-	return latest.IsZero() || !stamp.Before(latest.Add(interval))
-}

platform/service/plugin_data_test.go

@@ -98,28 +98,20 @@ func TestPluginDataTransactionValidationFailureDoesNotPartiallyApply(t *testing.
 	}
 }
 
-func TestDeclaredSQLiteQueryProjectsRowsIntoPluginCollection(t *testing.T) {
+func TestDeclaredSQLiteQueryDoesNotMutatePluginOrPlatformUserData(t *testing.T) {
 	svc, plugin, endpoint, session, instance := createSQLiteQueryBridgeFixture(t)
-	plugin.GameClientBridge.QueryTemplates[0].RowTarget = &domain.PluginDataRowTargetDeclaration{
-		Collection: "users",
-		UpsertKeys: []string{"userId"},
-		ColumnMappings: map[string]string{
-			"userId":      "user_id",
-			"displayName": "display_name",
-		},
+	if _, err := svc.PutPluginDataForSession(session, domain.PluginDataRecord{PluginID: plugin.ID, ServerInstanceID: instance.ID, Collection: "scum_users", Key: "steam-keep", Value: map[string]any{"steamId": "steam-keep", "format": "plugin-local"}}); err != nil {
+		t.Fatalf("seed plugin data: %v", err)
 	}
-	if err := svc.store.GamePlugins().Update(plugin); err != nil {
-		t.Fatalf("update plugin row target: %v", err)
-	}
-	queued, err := svc.ExecutePluginBridgeAction(session, domain.PluginBridgeExecuteRequest{RequestID: "query-project-1", PluginID: plugin.ID, RouteKey: "remote", ServerInstanceID: instance.ID, Action: domain.PluginBridgeActionRemoteAccessRequest, Payload: map[string]string{
-		"capability": domain.JobCapabilityRemoteRunDBSQLiteQuery, "declarationKey": "scum-db-read", "targetKey": "scum-db.player-lookup", "idempotencyKey": "query-project-1", "input.templateKey": "players.by-id",
+	queued, err := svc.ExecutePluginBridgeAction(session, domain.PluginBridgeExecuteRequest{RequestID: "query-no-projection-1", PluginID: plugin.ID, RouteKey: "remote", ServerInstanceID: instance.ID, Action: domain.PluginBridgeActionRemoteAccessRequest, Payload: map[string]string{
+		"capability": domain.JobCapabilityRemoteRunDBSQLiteQuery, "declarationKey": "scum-db-read", "targetKey": "scum-db.player-lookup", "idempotencyKey": "query-no-projection-1", "input.templateKey": "players.by-id",
 	}})
 	if err != nil || queued.Status != "queued" {
 		t.Fatalf("queue declared query=%+v err=%v", queued, err)
 	}
 	helloRequest := validRunControlHello()
 	helloRequest.CapabilityReport.Capabilities = append(helloRequest.CapabilityReport.Capabilities, domain.JobCapabilityRemoteRunDBSQLiteQuery)
-	helloRequest.CapabilityReport.Fingerprint = "cap-plugin-data-query"
+	helloRequest.CapabilityReport.Fingerprint = "cap-plugin-data-query-independent"
 	hello, err := svc.RegisterRunHello(helloRequest)
 	if err != nil {
 		t.Fatalf("register Run: %v", err)
@@ -132,170 +124,35 @@ func TestDeclaredSQLiteQueryProjectsRowsIntoPluginCollection(t *testing.T) {
 	if err != nil {
 		t.Fatalf("complete query job: %v", err)
 	}
-	items, err := svc.ListPluginDataForSession(session, domain.PluginDataFilter{PluginID: plugin.ID, ServerInstanceID: instance.ID, Collection: "users"})
-	if err != nil || len(items) != 2 || items[0].Key != "steam-1" || items[0].Value["displayName"] != "Ada" {
-		t.Fatalf("projected plugin rows=%+v err=%v", items, err)
+	items, err := svc.ListPluginDataForSession(session, domain.PluginDataFilter{PluginID: plugin.ID, ServerInstanceID: instance.ID, Collection: "scum_users"})
+	if err != nil || len(items) != 1 || items[0].Key != "steam-keep" || items[0].Value["format"] != "plugin-local" {
+		t.Fatalf("declared query mutated plugin data=%+v err=%v", items, err)
+	}
+	current, err := svc.GetCurrentUser(session)
+	if err != nil || current.ID != "user-query-owner" || current.Email != "query-owner@example.test" {
+		t.Fatalf("declared query mutated platform user session/user=%+v err=%v", current, err)
 	}
 }
 
-func TestDeclaredSQLiteQueryProjectionRejectsInvalidBatchAtomically(t *testing.T) {
-	svc, plugin, _, session, instance := createSQLiteQueryBridgeFixture(t)
-	plugin.GameClientBridge.QueryTemplates[0].RowTarget = &domain.PluginDataRowTargetDeclaration{
-		Collection: "members",
-		UpsertKeys: []string{"accountId"},
-		ColumnMappings: map[string]string{
-			"accountId":   "account_id",
-			"displayName": "display_name",
-		},
-	}
-	if err := svc.store.GamePlugins().Update(plugin); err != nil {
-		t.Fatalf("update plugin row target: %v", err)
-	}
-	job := domain.Job{
-		ServerInstanceID: instance.ID,
-		Capability:       domain.JobCapabilityRemoteRunDBSQLiteQuery,
-		State:            domain.JobStateSucceeded,
-		ExecutionInput:   domain.JobExecutionInput{Inputs: map[string]string{"templateKey": plugin.GameClientBridge.QueryTemplates[0].Key}},
-		ExecutionResult:  domain.JobExecutionResult{Content: `{"rows":[{"account_id":"one","display_name":"Ada","ignored":"value"},{"display_name":"Missing key"}]}`},
-	}
-	if err := svc.projectPluginDataJobResult(job); err == nil {
-		t.Fatal("expected missing upsert key error")
-	}
-	items, err := svc.ListPluginDataForSession(session, domain.PluginDataFilter{PluginID: plugin.ID, ServerInstanceID: instance.ID, Collection: "members"})
-	if err != nil || len(items) != 0 {
-		t.Fatalf("invalid projection batch partially applied values=%+v err=%v", items, err)
-	}
-}
-
-func TestDeclaredSQLiteQueryProjectionMergesPresenceAndReplacesCompleteSnapshots(t *testing.T) {
-	svc, plugin, _, session, instance := createSQLiteQueryBridgeFixture(t)
-	template := &plugin.GameClientBridge.QueryTemplates[0]
-	template.RowTarget = &domain.PluginDataRowTargetDeclaration{
-		Collection: "users", UpsertKeys: []string{"steamId"}, WriteMode: domain.PluginDataRowWriteModeMerge,
-		ColumnMappings: map[string]string{"steamId": "steam_id", "displayName": "display_name", "x": "x"},
-	}
-	if err := svc.store.GamePlugins().Update(plugin); err != nil {
-		t.Fatalf("update merge target: %v", err)
-	}
-	if _, err := svc.PutPluginDataForSession(session, domain.PluginDataRecord{PluginID: plugin.ID, ServerInstanceID: instance.ID, Collection: "users", Key: "steam-1", Value: map[string]any{"steamId": "steam-1", "online": true, "lastLoginAt": "2026-07-03T12:00:00Z"}}); err != nil {
-		t.Fatalf("seed stdout user: %v", err)
-	}
-	job := domain.Job{ServerInstanceID: instance.ID, Capability: domain.JobCapabilityRemoteRunDBSQLiteQuery, State: domain.JobStateSucceeded, ExecutionInput: domain.JobExecutionInput{Inputs: map[string]string{"templateKey": template.Key}}, ExecutionResult: domain.JobExecutionResult{Content: `{"rows":[{"steam_id":"steam-1","display_name":"Ada","x":12.5}]}`}}
-	if err := svc.projectPluginDataJobResult(job); err != nil {
-		t.Fatalf("merge query projection: %v", err)
-	}
-	users, err := svc.ListPluginDataForSession(session, domain.PluginDataFilter{PluginID: plugin.ID, ServerInstanceID: instance.ID, Collection: "users"})
-	if err != nil || len(users) != 1 || users[0].Value["online"] != true || users[0].Value["displayName"] != "Ada" {
-		t.Fatalf("merged users=%+v err=%v", users, err)
-	}
-
-	plugin.GameClientBridge.QueryTemplates[0].RowTarget = &domain.PluginDataRowTargetDeclaration{
-		Collection: "vehicles", UpsertKeys: []string{"vehicleId"}, WriteMode: domain.PluginDataRowWriteModeReplace,
-		ColumnMappings: map[string]string{"vehicleId": "vehicle_id", "x": "x"},
-	}
-	if err := svc.store.GamePlugins().Update(plugin); err != nil {
-		t.Fatalf("update replace target: %v", err)
-	}
-	for _, id := range []string{"keep", "gone"} {
-		if _, err := svc.PutPluginDataForSession(session, domain.PluginDataRecord{PluginID: plugin.ID, ServerInstanceID: instance.ID, Collection: "vehicles", Key: id, Value: map[string]any{"vehicleId": id}}); err != nil {
-			t.Fatalf("seed vehicle %s: %v", id, err)
-		}
-	}
-	job.ExecutionResult.Content = `{"rows":[{"vehicle_id":"keep","x":7}]}`
-	if err := svc.projectPluginDataJobResult(job); err != nil {
-		t.Fatalf("replace query projection: %v", err)
-	}
-	vehicles, err := svc.ListPluginDataForSession(session, domain.PluginDataFilter{PluginID: plugin.ID, ServerInstanceID: instance.ID, Collection: "vehicles"})
-	if err != nil || len(vehicles) != 1 || vehicles[0].Key != "keep" {
-		t.Fatalf("replaced vehicles=%+v err=%v", vehicles, err)
-	}
-	job.ExecutionResult.Content = `{"rows":[]}`
-	if err := svc.projectPluginDataJobResult(job); err != nil {
-		t.Fatalf("empty replace query projection: %v", err)
-	}
-	vehicles, err = svc.ListPluginDataForSession(session, domain.PluginDataFilter{PluginID: plugin.ID, ServerInstanceID: instance.ID, Collection: "vehicles"})
-	if err != nil || len(vehicles) != 0 {
-		t.Fatalf("empty replace did not clear vehicles=%+v err=%v", vehicles, err)
-	}
-}
-
-func TestRunPollSchedulesDueDeclaredPluginQueryWithoutBrowserSession(t *testing.T) {
-	svc, plugin, endpoint, _, instance := createSQLiteQueryBridgeFixture(t)
+func TestRunPollDoesNotSchedulePluginDataProjectionQueries(t *testing.T) {
+	svc, plugin, endpoint, _, _ := createSQLiteQueryBridgeFixture(t)
 	plugin.GameClientBridge.QueryTemplates[0].PollIntervalSeconds = 3
 	if err := svc.store.GamePlugins().Update(plugin); err != nil {
-		t.Fatalf("enable automatic query: %v", err)
+		t.Fatalf("enable query refresh hint: %v", err)
 	}
 	helloRequest := validRunControlHello()
 	helloRequest.CapabilityReport.Capabilities = append(helloRequest.CapabilityReport.Capabilities, domain.JobCapabilityRemoteRunDBSQLiteQuery)
-	helloRequest.CapabilityReport.Fingerprint = "cap-plugin-query-scheduler"
+	helloRequest.CapabilityReport.Fingerprint = "cap-plugin-query-no-scheduler"
 	hello, err := svc.RegisterRunHello(helloRequest)
 	if err != nil {
 		t.Fatalf("register Run: %v", err)
 	}
 	claim, err := svc.ClaimRunJob(domain.RunJobClaim{RunEndpointID: endpoint.ID, SessionToken: hello.SessionToken, Capabilities: []string{domain.JobCapabilityRemoteRunDBSQLiteQuery}, Capacity: domain.RunCapacity{MaxJobs: 1}})
-	if err != nil || !claim.HasJob || claim.Job == nil {
-		t.Fatalf("automatic query claim=%+v err=%v", claim, err)
-	}
-	if claim.Job.ServerInstanceID != instance.ID || claim.Job.Capability != domain.JobCapabilityRemoteRunDBSQLiteQuery || claim.Job.ExecutionInput.Inputs["templateKey"] != "players.by-id" || claim.Job.ExecutionInput.Inputs["limit"] != "25" {
-		t.Fatalf("unexpected automatic query assignment: %+v", claim.Job)
+	if err != nil || claim.HasJob {
+		t.Fatalf("automatic projection query was scheduled: %+v err=%v", claim, err)
 	}
 	jobs, err := svc.store.Jobs().List(domain.JobFilter{RunEndpointID: endpoint.ID})
-	if err != nil || len(jobs) != 1 {
-		t.Fatalf("automatic query jobs=%+v err=%v", jobs, err)
-	}
-	second, err := svc.ClaimRunJob(domain.RunJobClaim{RunEndpointID: endpoint.ID, SessionToken: hello.SessionToken, Capabilities: []string{domain.JobCapabilityRemoteRunDBSQLiteQuery}, Capacity: domain.RunCapacity{MaxJobs: 1, RunningJobs: 1}})
-	if err != nil || second.HasJob {
-		t.Fatalf("overlapping automatic query was not suppressed: %+v err=%v", second, err)
-	}
-	jobs, err = svc.store.Jobs().List(domain.JobFilter{RunEndpointID: endpoint.ID})
-	if err != nil || len(jobs) != 1 {
-		t.Fatalf("overlap created duplicate jobs=%+v err=%v", jobs, err)
-	}
-}
-
-func TestDeclaredSQLiteQueryProjectionFailureKeepsJobRetryable(t *testing.T) {
-	svc, plugin, endpoint, session, instance := createSQLiteQueryBridgeFixture(t)
-	plugin.GameClientBridge.QueryTemplates[0].RowTarget = &domain.PluginDataRowTargetDeclaration{
-		Collection: "members",
-		UpsertKeys: []string{"accountId"},
-		ColumnMappings: map[string]string{
-			"accountId":   "account_id",
-			"displayName": "display_name",
-		},
-	}
-	if err := svc.store.GamePlugins().Update(plugin); err != nil {
-		t.Fatalf("update plugin row target: %v", err)
-	}
-	queued, err := svc.ExecutePluginBridgeAction(session, domain.PluginBridgeExecuteRequest{RequestID: "query-invalid-projection", PluginID: plugin.ID, RouteKey: "remote", ServerInstanceID: instance.ID, Action: domain.PluginBridgeActionRemoteAccessRequest, Payload: map[string]string{
-		"capability": domain.JobCapabilityRemoteRunDBSQLiteQuery, "declarationKey": "scum-db-read", "targetKey": "scum-db.player-lookup", "idempotencyKey": "query-invalid-projection", "input.templateKey": "players.by-id",
-	}})
-	if err != nil || queued.Status != "queued" {
-		t.Fatalf("queue declared query=%+v err=%v", queued, err)
-	}
-	helloRequest := validRunControlHello()
-	helloRequest.CapabilityReport.Capabilities = append(helloRequest.CapabilityReport.Capabilities, domain.JobCapabilityRemoteRunDBSQLiteQuery)
-	helloRequest.CapabilityReport.Fingerprint = "cap-plugin-data-invalid-query"
-	hello, err := svc.RegisterRunHello(helloRequest)
-	if err != nil {
-		t.Fatalf("register Run: %v", err)
-	}
-	claim, err := svc.ClaimRunJob(domain.RunJobClaim{RunEndpointID: endpoint.ID, SessionToken: hello.SessionToken, Capabilities: []string{domain.JobCapabilityRemoteRunDBSQLiteQuery}, Capacity: domain.RunCapacity{MaxJobs: 1}})
-	if err != nil || !claim.HasJob || claim.Job == nil {
-		t.Fatalf("claim query job=%+v err=%v", claim, err)
-	}
-	result := domain.RunJobResult{RunEndpointID: endpoint.ID, SessionToken: hello.SessionToken, JobID: claim.Job.JobID, LeaseToken: claim.Job.LeaseToken, Attempt: claim.Job.Attempt, State: domain.JobStateSucceeded, Progress: domain.RunJobProgressReport{Percent: 100}, ExecutionResult: domain.JobExecutionResult{Kind: "sqlite.query", Content: `{"rows":[{"display_name":"Missing key"}]}`}}
-	if _, err := svc.CompleteRunJob(result); err == nil {
-		t.Fatal("expected projection failure")
-	}
-	job, err := svc.store.Jobs().Get(claim.Job.JobID)
-	if err != nil || isTerminalJobState(job.State) {
-		t.Fatalf("projection failure persisted terminal job=%+v err=%v", job, err)
-	}
-	if _, err := svc.CompleteRunJob(result); err == nil {
-		t.Fatal("expected projection retry to re-run and fail")
-	}
-	items, err := svc.ListPluginDataForSession(session, domain.PluginDataFilter{PluginID: plugin.ID, ServerInstanceID: instance.ID, Collection: "members"})
-	if err != nil || len(items) != 0 {
-		t.Fatalf("invalid retry projected records=%+v err=%v", items, err)
+	if err != nil || len(jobs) != 0 {
+		t.Fatalf("automatic projection query persisted jobs=%+v err=%v", jobs, err)
 	}
 }

platform/service/resources_test.go

@@ -1846,7 +1846,6 @@ func createSQLiteQueryBridgeFixture(t *testing.T) (*CoreService, domain.GamePlug
 				SQLRef:             "sql/players.by-id.sql",
 				MaxRows:            25,
 				TimeoutSeconds:     20,
-				RowTarget:          &domain.PluginDataRowTargetDeclaration{Collection: "players", UpsertKeys: []string{"userId"}, ColumnMappings: map[string]string{"userId": "user_id"}},
 			},
 		},
 		Retention: domain.GameClientBridgeRetention{KeepForSeconds: 3600, MaxRecords: 100},

platform/validator/resources.go

@@ -572,32 +572,8 @@ func validateGameClientBridgeManifest(field string, bridge domain.GameClientBrid
 		if template.PollIntervalSeconds < 0 || template.PollIntervalSeconds > 86400 {
 			violations = append(violations, prefix+".pollIntervalSeconds is invalid")
 		}
-		projectsRows := template.SQLRef != "" || template.RowTarget != nil
-		if projectsRows {
-			if !safeRelativeSQLRef(template.SQLRef) {
-				violations = append(violations, prefix+".sqlRef must reference a package-relative SQL asset")
-			}
-			if template.RowTarget == nil {
-				violations = append(violations, prefix+".rowTarget is required for projected queries")
-			} else {
-				target := template.RowTarget
-				if !clientManagerIdentifierPattern.MatchString(target.Collection) || len(target.UpsertKeys) == 0 || len(target.ColumnMappings) == 0 {
-					violations = append(violations, prefix+".rowTarget must declare a collection, upsert keys, and column mappings")
-				}
-				if target.WriteMode != "" && target.WriteMode != domain.PluginDataRowWriteModeMerge && target.WriteMode != domain.PluginDataRowWriteModeReplace {
-					violations = append(violations, prefix+".rowTarget.writeMode must be merge or replace")
-				}
-				for _, key := range target.UpsertKeys {
-					if !clientManagerIdentifierPattern.MatchString(key) {
-						violations = append(violations, prefix+".rowTarget upsert key is invalid")
-					}
-				}
-				for destination, source := range target.ColumnMappings {
-					if !clientManagerIdentifierPattern.MatchString(destination) || !clientManagerIdentifierPattern.MatchString(source) {
-						violations = append(violations, prefix+".rowTarget column mapping is invalid")
-					}
-				}
-			}
+		if template.SQLRef != "" && !safeRelativeSQLRef(template.SQLRef) {
+			violations = append(violations, prefix+".sqlRef must reference a package-relative SQL asset")
 		}
 		transport, exists := transports[template.TransportKey]
 		if !exists {

platform/validator/resources_test.go

@@ -201,9 +201,8 @@ func TestValidateGamePluginManifestRegistrationValidatesGameClientBridgeCatalog(
 		{name: "poll interval bound", expected: "pollIntervalSeconds is invalid", mutate: func(value *domain.GamePluginManifestRegistration) {
 			value.Manifest.GameClientBridge.QueryTemplates[0].PollIntervalSeconds = 86401
 		}},
-		{name: "write mode", expected: "writeMode must be merge or replace", mutate: func(value *domain.GamePluginManifestRegistration) {
-			value.Manifest.GameClientBridge.QueryTemplates[0].SQLRef = "sql/player-lookup.sql"
-			value.Manifest.GameClientBridge.QueryTemplates[0].RowTarget = &domain.PluginDataRowTargetDeclaration{Collection: "users", UpsertKeys: []string{"userId"}, ColumnMappings: map[string]string{"userId": "user_id"}, WriteMode: "append"}
+		{name: "unsafe SQL asset", expected: "sqlRef must reference", mutate: func(value *domain.GamePluginManifestRegistration) {
+			value.Manifest.GameClientBridge.QueryTemplates[0].SQLRef = "/etc/player-lookup.sql"
 		}},
 		{name: "unknown transport", expected: "transportKey must reference", mutate: func(value *domain.GamePluginManifestRegistration) {
 			value.Manifest.GameClientBridge.QueryTemplates[0].TransportKey = "missing"