SY-3833-2: Add Schematic Action Codec and Dispatch Endpoint

Lays the server-side foundation for granular schematic mutations.

Oracle codegen:
- Adds the 'action' grammar production to the oracle DSL alongside fields,
  domains, and field omissions inside struct bodies.
- Adds resolution.Action and analyzer.collectAction. resolveTypeRefs now
  walks action payload field types so cross-references inside action bodies
  resolve correctly to their qualified names.
- New oracle/plugin/go/actions plugin generates a discriminated-union
  codec (Action envelope, Reduce, ReduceAll, NewXxxAction constructors)
  for any struct that declares actions. Optional fields use the same
  pointer-prefix logic as gotypes (skip slice / map / msgpack.EncodedJSON).
- Formatter learns to emit action blocks so 'oracle fmt' / 'oracle sync'
  preserves them.

Schematic schema and runtime:
- schemas/schematic.oracle declares six actions: SetNodePosition, AddNode,
  RemoveNode, SetEdge, RemoveEdge, SetProps. Hand-written Handle methods
  live in core/pkg/service/schematic/actions.go alongside the ScopedAction
  envelope used for cluster broadcast.
- Writer.Dispatch applies a sequence of actions atomically inside a single
  gorp transaction, rejects snapshots, and notifies actionObserver on
  success. SetData remains in place; no callers are migrated yet.
- Service wires actionObserver to a signals translator that publishes
  scoped action sequences to sy_schematic_set / sy_schematic_delete when
  cfg.Signals is non-nil.
- API exposes Dispatch as a new freighter endpoint
  (/api/v1/schematic/dispatch) registered alongside the existing
  SetData endpoint.

Author: emilbon99

core/pkg/api/grpc/grpc.go

@@ -106,6 +106,7 @@ func NewTransport(channelSvc *distchannel.Service) (api.Transport, []grpc.Bindab
 	a.SchematicRetrieve = fnoop.UnaryServer[schematic.RetrieveRequest, schematic.RetrieveResponse]{}
 	a.SchematicRename = fnoop.UnaryServer[schematic.RenameRequest, types.Nil]{}
 	a.SchematicSetData = fnoop.UnaryServer[schematic.SetDataRequest, types.Nil]{}
+	a.SchematicDispatch = fnoop.UnaryServer[schematic.DispatchRequest, types.Nil]{}
 	a.SchematicCopy = fnoop.UnaryServer[schematic.CopyRequest, schematic.CopyResponse]{}
 
 	// SCHEMATIC SYMBOL

core/pkg/api/http/http.go

@@ -113,6 +113,7 @@ func NewTransport(router *fhttp.Router, ch *distchannel.Service) api.Transport {
 		SchematicDelete:   fhttp.UnaryServer[schematic.DeleteRequest, types.Nil](router, "/api/v1/schematic/delete"),
 		SchematicRename:   fhttp.UnaryServer[schematic.RenameRequest, types.Nil](router, "/api/v1/schematic/rename"),
 		SchematicSetData:  fhttp.UnaryServer[schematic.SetDataRequest, types.Nil](router, "/api/v1/schematic/set-data"),
+		SchematicDispatch: fhttp.UnaryServer[schematic.DispatchRequest, types.Nil](router, "/api/v1/schematic/dispatch"),
 		SchematicCopy:     fhttp.UnaryServer[schematic.CopyRequest, schematic.CopyResponse](router, "/api/v1/schematic/copy"),
 
 		// SCHEMATIC SYMBOL

core/pkg/api/layer.go

@@ -110,6 +110,7 @@ type Transport struct {
 	SchematicDelete   freighter.UnaryServer[schematic.DeleteRequest, types.Nil]
 	SchematicRename   freighter.UnaryServer[schematic.RenameRequest, types.Nil]
 	SchematicSetData  freighter.UnaryServer[schematic.SetDataRequest, types.Nil]
+	SchematicDispatch freighter.UnaryServer[schematic.DispatchRequest, types.Nil]
 	SchematicCopy     freighter.UnaryServer[schematic.CopyRequest, schematic.CopyResponse]
 	// SCHEMATIC SYMBOL
 	SchematicCreateSymbol        freighter.UnaryServer[schematic.CreateSymbolRequest, schematic.CreateSymbolResponse]
@@ -292,6 +293,7 @@ func (l *Layer) BindTo(t Transport) {
 		t.SchematicDelete,
 		t.SchematicRename,
 		t.SchematicSetData,
+		t.SchematicDispatch,
 		t.SchematicCopy,
 
 		// SCHEMATIC SYMBOL
@@ -438,6 +440,7 @@ func (l *Layer) BindTo(t Transport) {
 	t.SchematicDelete.BindHandler(l.Schematic.Delete)
 	t.SchematicRename.BindHandler(l.Schematic.Rename)
 	t.SchematicSetData.BindHandler(l.Schematic.SetData)
+	t.SchematicDispatch.BindHandler(l.Schematic.Dispatch)
 	t.SchematicCopy.BindHandler(l.Schematic.Copy)
 
 	// SCHEMATIC SYMBOL

core/pkg/api/schematic/schematic.go

@@ -110,6 +110,31 @@ func (s *Service) SetData(ctx context.Context, req SetDataRequest) (res types.Ni
 	})
 }
 
+// DispatchRequest carries an action sequence to apply to a single schematic.
+// SessionKey identifies the originating client so cluster broadcasts can be
+// deduplicated against the local optimistic update.
+type DispatchRequest struct {
+	Key        uuid.UUID          `json:"key" msgpack:"key"`
+	SessionKey string             `json:"session_key" msgpack:"session_key"`
+	Actions    []schematic.Action `json:"actions" msgpack:"actions"`
+}
+
+// Dispatch applies the action sequence to the target schematic atomically.
+// Subscribers to the schematic action signals receive the sequence after the
+// transaction commits.
+func (s *Service) Dispatch(ctx context.Context, req DispatchRequest) (res types.Nil, err error) {
+	if err = s.access.Enforce(ctx, access.Request{
+		Subject: auth.GetSubject(ctx),
+		Action:  access.ActionUpdate,
+		Objects: []ontology.ID{schematic.OntologyID(req.Key)},
+	}); err != nil {
+		return res, err
+	}
+	return res, s.db.WithTx(ctx, func(tx gorp.Tx) error {
+		return s.internal.NewWriter(tx).Dispatch(ctx, req.Key, req.SessionKey, req.Actions)
+	})
+}
+
 type (
 	RetrieveRequest struct {
 		Keys []uuid.UUID `json:"keys" msgpack:"keys"`

core/pkg/service/schematic/actions.gen.go

@@ -0,0 +1,95 @@
+// Copyright 2026 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+package schematic
+
+import (
+	"github.com/google/uuid"
+	"github.com/synnaxlabs/x/encoding/msgpack"
+)
+
+// ScopedAction wraps an action sequence with the targeted schematic key and the
+// originating client's session key. Subscribers to the action signal channel
+// compare SessionKey against their own client key to skip self-originated
+// updates (optimistic-UI dedup).
+type ScopedAction struct {
+	Key        uuid.UUID `json:"key" msgpack:"key"`
+	SessionKey string    `json:"session_key" msgpack:"session_key"`
+	Actions    []Action  `json:"actions" msgpack:"actions"`
+}
+
+// Handle moves the named node to the given position. No-op if no node matches.
+func (a SetNodePosition) Handle(state Schematic) (Schematic, error) {
+	for i := range state.Nodes {
+		if state.Nodes[i].Key == a.Key {
+			state.Nodes[i].Position = a.Position
+			break
+		}
+	}
+	return state, nil
+}
+
+// Handle appends the node and, if Props is non-nil, seeds the props map under
+// the node's key.
+func (a AddNode) Handle(state Schematic) (Schematic, error) {
+	state.Nodes = append(state.Nodes, a.Node)
+	if a.Props != nil {
+		if state.Props == nil {
+			state.Props = make(map[string]msgpack.EncodedJSON)
+		}
+		state.Props[a.Node.Key] = a.Props
+	}
+	return state, nil
+}
+
+// Handle removes the node with the matching key and discards any props entry
+// stored under that key.
+func (a RemoveNode) Handle(state Schematic) (Schematic, error) {
+	for i := range state.Nodes {
+		if state.Nodes[i].Key == a.Key {
+			state.Nodes = append(state.Nodes[:i], state.Nodes[i+1:]...)
+			break
+		}
+	}
+	delete(state.Props, a.Key)
+	return state, nil
+}
+
+// Handle inserts the edge if no edge with the same key exists, otherwise
+// replaces the existing edge in place.
+func (a SetEdge) Handle(state Schematic) (Schematic, error) {
+	for i := range state.Edges {
+		if state.Edges[i].Key == a.Edge.Key {
+			state.Edges[i] = a.Edge
+			return state, nil
+		}
+	}
+	state.Edges = append(state.Edges, a.Edge)
+	return state, nil
+}
+
+// Handle removes the edge with the matching key. No-op if no edge matches.
+func (a RemoveEdge) Handle(state Schematic) (Schematic, error) {
+	for i := range state.Edges {
+		if state.Edges[i].Key == a.Key {
+			state.Edges = append(state.Edges[:i], state.Edges[i+1:]...)
+			break
+		}
+	}
+	return state, nil
+}
+
+// Handle sets the props entry for the given key, replacing any prior value.
+func (a SetProps) Handle(state Schematic) (Schematic, error) {
+	if state.Props == nil {
+		state.Props = make(map[string]msgpack.EncodedJSON)
+	}
+	state.Props[a.Key] = a.Props
+	return state, nil
+}