re s/guuid/uuid/g

2 files changed, 273 insertions, 273 deletions

diff --git a/src/papod.go b/src/papod.go
index fc2d10d..7e422f7 100644
--- a/src/papod.go
+++ b/src/papod.go
@@ -18,7 +18,7 @@ import (
 	"cracha"
 	"fiinha"
 	"golite"
-	"guuid"
+	"uuid"
 	"pds"
 	"stm"
 	g "gobang"
@@ -51,11 +51,11 @@ type queryT struct{
 
 type queriesT struct{
 	createUser func(newUserT) (userT, error)
-	userByUUID func(guuid.UUID) (userT, error)
+	userByUUID func(uuid.UUID) (userT, error)
 	updateUser func(userT) error
-	deleteUser func(guuid.UUID) error
-	addNetwork func(userT, newNetworkT, guuid.UUID) (networkT, error)
-	getNetwork func(userT, guuid.UUID) (networkT, error)
+	deleteUser func(uuid.UUID) error
+	addNetwork func(userT, newNetworkT, uuid.UUID) (networkT, error)
+	getNetwork func(userT, uuid.UUID) (networkT, error)
 	networks   func(userT, func(networkT) error) error
 	setNetwork func(memberT, networkT) error
 	nipNetwork func(memberT) error
@@ -63,26 +63,26 @@ type queriesT struct{
 	addMember  func(memberT, newMemberT) (memberT, error)
 	addRole    func(memberT, string, memberT) error
 	dropRole   func(memberT, string, memberT) error
-	showMember func(memberT, guuid.UUID) (memberT, error)
+	showMember func(memberT, uuid.UUID) (memberT, error)
 	members    func(memberT, func(memberT) error) error
 	editMember func(memberT, memberT) error
-	dropMember func(memberT, guuid.UUID) error
+	dropMember func(memberT, uuid.UUID) error
 	addChannel func(memberT, newChannelT) (channelT, error)
 	chanByName func(memberT, string) (channelT, error)
 	channels   func(memberT, func(channelT) error) error
 	setChannel func(memberT, channelT) error
-	endChannel func(memberT, guuid.UUID) error
-	join       func(memberT, guuid.UUID) error
+	endChannel func(memberT, uuid.UUID) error
+	join       func(memberT, uuid.UUID) error
 	part       func(memberT, channelT) error
-	names      func(memberT, guuid.UUID, func(memberT) error) error
+	names      func(memberT, uuid.UUID, func(memberT) error) error
 	addEvent   func(newEventT) (eventT, error)
-	allAfter   func(memberT, guuid.UUID, func(eventT) error) error
+	allAfter   func(memberT, uuid.UUID, func(eventT) error) error
 	logMessage func(userT, messageT) error
 	close      func() error
 }
 
 type newUserT struct{
-	uuid        guuid.UUID
+	uuid        uuid.UUID
 	username    string
 	displayName string
 }
@@ -90,10 +90,10 @@ type newUserT struct{
 type userT struct{
 	id          int64
 	timestamp   time.Time
-	uuid        guuid.UUID
+	uuid        uuid.UUID
 	username    string
 	displayName string
-	pictureID   *guuid.UUID
+	pictureID   *uuid.UUID
 }
 
 type NetworkType string
@@ -111,7 +111,7 @@ const (
 )
 
 type newNetworkT struct{
-	uuid        guuid.UUID
+	uuid        uuid.UUID
 	name        string
 	description string
 	type_       NetworkType
@@ -120,25 +120,25 @@ type newNetworkT struct{
 type networkT struct{
 	id          int64
 	timestamp   time.Time
-	uuid        guuid.UUID
+	uuid        uuid.UUID
 	name        string
 	description string
 	type_       NetworkType
 }
 
 type newMemberT struct{
-	userID   guuid.UUID
-	memberID guuid.UUID
+	userID   uuid.UUID
+	memberID uuid.UUID
 	username string
 }
 
 type memberT struct{
 	id          int64
 	timestamp   time.Time
-	uuid        guuid.UUID
+	uuid        uuid.UUID
 	username    string
 	displayName string
-	pictureID   *guuid.UUID
+	pictureID   *uuid.UUID
 	status      MemberStatus
 	roles       []string
 }
@@ -146,7 +146,7 @@ type memberT struct{
 type newChannelT struct{
 	id          int64
 	timestamp   time.Time
-	uuid        guuid.UUID
+	uuid        uuid.UUID
 	publicName  *string
 	label       string
 	description string
@@ -156,7 +156,7 @@ type newChannelT struct{
 type channelT struct{
 	id          int64
 	timestamp   time.Time
-	uuid        guuid.UUID
+	uuid        uuid.UUID
 	publicName  *string
 	label       string
 	description string
@@ -169,7 +169,7 @@ const (
 )
 
 type sourceT struct{
-	uuid     guuid.UUID
+	uuid     uuid.UUID
 	type_    SourceType
 	metadata *map[string]interface{}
 }
@@ -181,8 +181,8 @@ const (
 )
 
 type newEventT struct{
-	eventID   guuid.UUID
-	channelID guuid.UUID
+	eventID   uuid.UUID
+	channelID uuid.UUID
 	source    sourceT
 	type_     EventType
 	payload   string
@@ -192,8 +192,8 @@ type newEventT struct{
 type eventT struct{
 	id        int64
 	timestamp time.Time
-	uuid      guuid.UUID
-	channelID guuid.UUID
+	uuid      uuid.UUID
+	channelID uuid.UUID
 	source    sourceT
 	type_     EventType
 	payload   string
@@ -237,7 +237,7 @@ type netConnI interface{
 }
 
 type connectionT struct{
-	uuid guuid.UUID
+	uuid uuid.UUID
 	user *userT
 	conn netConnI
 	send func(messageT)
@@ -258,15 +258,15 @@ type stateMutableT struct{
 
 type stateT struct{
 	members     *pds.Map[string, []string]
-	users       *pds.Map[string, []guuid.UUID]
-	connections *pds.Map[guuid.UUID, connectionT]
+	users       *pds.Map[string, []uuid.UUID]
+	connections *pds.Map[uuid.UUID, connectionT]
 }
 
 // TODO: key for members should be the channelID, not its name
 type stateMutableDataT struct{
-	connections map[guuid.UUID]*connectionT
-	users       map[string][]guuid.UUID
-	members     map[string]map[string][]guuid.UUID
+	connections map[uuid.UUID]*connectionT
+	users       map[string][]uuid.UUID
+	members     map[string]map[string][]uuid.UUID
 }
 
 type papodT struct{
@@ -1238,7 +1238,7 @@ func userByUUIDSQL(prefix string) queryT {
 
 func userByUUIDStmt(
 	cfg dbconfigT,
-) (func(guuid.UUID) (userT, error), func() error, error) {
+) (func(uuid.UUID) (userT, error), func() error, error) {
 	q := userByUUIDSQL(cfg.prefix)
 
 	readStmt, err := cfg.shared.Prepare(q.read)
@@ -1246,7 +1246,7 @@ func userByUUIDStmt(
 		return nil, nil, err
 	}
 
-	fn := func(userID guuid.UUID) (userT, error) {
+	fn := func(userID uuid.UUID) (userT, error) {
 		user := userT{
 			uuid: userID,
 		}
@@ -1266,7 +1266,7 @@ func userByUUIDStmt(
 			return userT{}, err
 		}
 		if picture_id_bytes != nil {
-			pictureID := guuid.UUID(picture_id_bytes)
+			pictureID := uuid.UUID(picture_id_bytes)
 			user.pictureID = &pictureID
 		}
 
@@ -1341,7 +1341,7 @@ func deleteUserSQL(prefix string) queryT {
 
 func deleteUserStmt(
 	cfg dbconfigT,
-) (func(guuid.UUID) error, func() error, error) {
+) (func(uuid.UUID) error, func() error, error) {
 	q := deleteUserSQL(cfg.prefix)
 
 	writeStmt, err := cfg.shared.Prepare(q.write)
@@ -1349,7 +1349,7 @@ func deleteUserStmt(
 		return nil, nil, err
 	}
 
-	fn := func(userID guuid.UUID) error {
+	fn := func(userID uuid.UUID) error {
 		var _id int64
 		return writeStmt.QueryRow(userID[:]).Scan(&_id)
 	}
@@ -1426,7 +1426,7 @@ func addNetworkSQL(prefix string) queryT {
 func addNetworkStmt(
 	cfg dbconfigT,
 ) (
-	func(userT, newNetworkT, guuid.UUID) (networkT, error),
+	func(userT, newNetworkT, uuid.UUID) (networkT, error),
 	func() error,
 	error,
 ) {
@@ -1448,7 +1448,7 @@ func addNetworkStmt(
 	fn := func(
 		user userT,
 		newNetwork newNetworkT,
-		memberID guuid.UUID,
+		memberID uuid.UUID,
 	) (networkT, error) {
 		network := networkT{
 			uuid:        newNetwork.uuid,
@@ -1559,7 +1559,7 @@ func getNetworkSQL(prefix string) queryT {
 
 func getNetworkStmt(
 	cfg dbconfigT,
-) (func(userT, guuid.UUID) (networkT, error), func() error, error) {
+) (func(userT, uuid.UUID) (networkT, error), func() error, error) {
 	q := getNetworkSQL(cfg.prefix)
 
 	readStmt, err := cfg.shared.Prepare(q.read)
@@ -1567,7 +1567,7 @@ func getNetworkStmt(
 		return nil, nil, err
 	}
 
-	fn := func(user userT, networkID guuid.UUID) (networkT, error) {
+	fn := func(user userT, networkID uuid.UUID) (networkT, error) {
 		network := networkT{
 			uuid: networkID,
 		}
@@ -1626,7 +1626,7 @@ func networkEach(rows *sql.Rows, callback func(networkT) error) error {
 		if err != nil {
 			return g.WrapErrors(rows.Close(), err)
 		}
-		network.uuid = guuid.UUID(network_id_bytes)
+		network.uuid = uuid.UUID(network_id_bytes)
 
 		if deleted {
 			return sql.ErrNoRows
@@ -1905,7 +1905,7 @@ func membershipStmt(
 		if err != nil {
 			return memberT{}, err
 		}
-		member.uuid = guuid.UUID(member_id_bytes)
+		member.uuid = uuid.UUID(member_id_bytes)
 
 		member.timestamp, err = time.Parse(time.RFC3339Nano, timestr)
 		if err != nil {
@@ -2041,7 +2041,7 @@ func addMemberStmt(
 			return memberT{}, err
 		}
 		if picture_id_bytes != nil {
-			pictureID := guuid.UUID(picture_id_bytes)
+			pictureID := uuid.UUID(picture_id_bytes)
 			member.pictureID = &pictureID
 		}
 
@@ -2163,7 +2163,7 @@ func showMemberSQL(prefix string) queryT {
 
 func showMemberStmt(
 	cfg dbconfigT,
-) (func(memberT, guuid.UUID) (memberT, error), func() error, error) {
+) (func(memberT, uuid.UUID) (memberT, error), func() error, error) {
 	q := showMemberSQL(cfg.prefix)
 
 	readStmt, err := cfg.shared.Prepare(q.read)
@@ -2177,7 +2177,7 @@ func showMemberStmt(
 		return nil, nil, err
 	}
 
-	fn := func(actor memberT, memberID guuid.UUID) (memberT, error) {
+	fn := func(actor memberT, memberID uuid.UUID) (memberT, error) {
 		member := memberT{
 			uuid: memberID,
 		}
@@ -2198,7 +2198,7 @@ func showMemberStmt(
 			return memberT{}, err
 		}
 		if picture_id_bytes != nil {
-			pictureID := guuid.UUID(picture_id_bytes)
+			pictureID := uuid.UUID(picture_id_bytes)
 			//  FIXME: test this
 			member.pictureID = &pictureID
 		}
@@ -2255,9 +2255,9 @@ func memberEach(rows *sql.Rows, callback func(memberT) error) error {
 		if err != nil {
 			return g.WrapErrors(rows.Close(), err)
 		}
-		member.uuid = guuid.UUID(member_id_bytes)
+		member.uuid = uuid.UUID(member_id_bytes)
 		if picture_id_bytes != nil {
-			pictureID := guuid.UUID(picture_id_bytes)
+			pictureID := uuid.UUID(picture_id_bytes)
 			member.pictureID = &pictureID
 		}
 
@@ -2385,7 +2385,7 @@ func dropMemberSQL(prefix string) queryT {
 
 func dropMemberStmt(
 	cfg dbconfigT,
-) (func(memberT, guuid.UUID) error, func() error, error) {
+) (func(memberT, uuid.UUID) error, func() error, error) {
 	q := dropMemberSQL(cfg.prefix)
 
 	privateDB, err := sql.Open(golite.DriverName, cfg.dbpath)
@@ -2395,7 +2395,7 @@ func dropMemberStmt(
 
 	writeFn, writeFnClose := execSerialized(q.write, privateDB)
 
-	fn := func(actor memberT, memberID guuid.UUID) error {
+	fn := func(actor memberT, memberID uuid.UUID) error {
 		err := writeFn(memberID[:], memberID[:])
 		if err != nil {
 			return err
@@ -2566,7 +2566,7 @@ func channelEach(rows *sql.Rows, callback func(channelT) error) error {
 		if err != nil {
 			return g.WrapErrors(rows.Close(), err)
 		}
-		channel.uuid = guuid.UUID(channel_id_bytes)
+		channel.uuid = uuid.UUID(channel_id_bytes)
 		if publicName.Valid {
 			channel.publicName = &publicName.String
 		}
@@ -2731,7 +2731,7 @@ func endChannelSQL(prefix string) queryT {
 
 func endChannelStmt(
 	cfg dbconfigT,
-) (func(memberT, guuid.UUID) error, func() error, error) {
+) (func(memberT, uuid.UUID) error, func() error, error) {
 	q := endChannelSQL(cfg.prefix)
 
 	writeStmt, err := cfg.shared.Prepare(q.write)
@@ -2739,7 +2739,7 @@ func endChannelStmt(
 		return nil, nil, err
 	}
 
-	fn := func(actor memberT, channelID guuid.UUID) error {
+	fn := func(actor memberT, channelID uuid.UUID) error {
 		_, err := writeStmt.Exec(channelID[:])
 		return err
 	}
@@ -2782,7 +2782,7 @@ func joinSQL(prefix string) queryT {
 
 func joinStmt(
 	cfg dbconfigT,
-) (func(memberT, guuid.UUID) error, func() error, error) {
+) (func(memberT, uuid.UUID) error, func() error, error) {
 	q := joinSQL(cfg.prefix)
 
 	readStmt, err := cfg.shared.Prepare(q.read)
@@ -2796,7 +2796,7 @@ func joinStmt(
 		return nil, nil, err
 	}
 
-	fn := func(actor memberT, channelID guuid.UUID) error {
+	fn := func(actor memberT, channelID uuid.UUID) error {
 		var (
 			netid1 sql.NullInt64
 			netid2 sql.NullInt64
@@ -2885,7 +2885,7 @@ func nameEach(rows *sql.Rows, callback func(memberT) error) error {
 		if err != nil {
 			return g.WrapErrors(rows.Close(), err)
 		}
-		member.uuid = guuid.UUID(member_id_bytes)
+		member.uuid = uuid.UUID(member_id_bytes)
 
 		member.timestamp, err = time.Parse(time.RFC3339Nano, timestr)
 		if err != nil {
@@ -2912,7 +2912,7 @@ func namesSQL(prefix string) queryT {
 
 func namesStmt(
 	cfg dbconfigT,
-) (func(memberT, guuid.UUID) (*sql.Rows, error), func() error, error) {
+) (func(memberT, uuid.UUID) (*sql.Rows, error), func() error, error) {
 	q := namesSQL(cfg.prefix)
 
 	readStmt, err := cfg.shared.Prepare(q.read)
@@ -2920,7 +2920,7 @@ func namesStmt(
 		return nil, nil, err
 	}
 
-	fn := func(actor memberT, channelID guuid.UUID) (*sql.Rows, error) {
+	fn := func(actor memberT, channelID uuid.UUID) (*sql.Rows, error) {
 		return readStmt.Query(channelID[:])
 	}
 
@@ -3018,8 +3018,8 @@ func eventEach(rows *sql.Rows, callback func(eventT) error) error {
 			rows.Close()
 			return err
 		}
-		event.uuid         = guuid.UUID(event_id_bytes)
-		event.channelID    = guuid.UUID(channel_id_bytes)
+		event.uuid         = uuid.UUID(event_id_bytes)
+		event.channelID    = uuid.UUID(channel_id_bytes)
 
 		event.timestamp, err = time.Parse(time.RFC3339Nano, timestr)
 		if err != nil {
@@ -3084,7 +3084,7 @@ func allAfterSQL(prefix string) queryT {
 
 func allAfterStmt(
 	cfg dbconfigT,
-) (func (memberT, guuid.UUID) (*sql.Rows, error), func() error, error) {
+) (func (memberT, uuid.UUID) (*sql.Rows, error), func() error, error) {
 	q := allAfterSQL(cfg.prefix)
 
 	readStmt, err := cfg.shared.Prepare(q.read)
@@ -3092,7 +3092,7 @@ func allAfterStmt(
 		return nil, nil, err
 	}
 
-	fn := func(actor memberT, eventID guuid.UUID) (*sql.Rows, error) {
+	fn := func(actor memberT, eventID uuid.UUID) (*sql.Rows, error) {
 		return readStmt.Query(eventID[:])
 	}
 
@@ -3251,7 +3251,7 @@ func initDB(
 			defer connMutex.RUnlock()
 			return createUser(a)
 		},
-		userByUUID: func(a guuid.UUID) (userT, error) {
+		userByUUID: func(a uuid.UUID) (userT, error) {
 			connMutex.RLock()
 			defer connMutex.RUnlock()
 			return userByUUID(a)
@@ -3261,7 +3261,7 @@ func initDB(
 			defer connMutex.RUnlock()
 			return updateUser(a)
 		},
-		deleteUser: func(a guuid.UUID) error {
+		deleteUser: func(a uuid.UUID) error {
 			connMutex.RLock()
 			defer connMutex.RUnlock()
 			return deleteUser(a)
@@ -3269,13 +3269,13 @@ func initDB(
 		addNetwork: func(
 			a userT,
 			b newNetworkT,
-			c guuid.UUID,
+			c uuid.UUID,
 		) (networkT, error) {
 			connMutex.RLock()
 			defer connMutex.RUnlock()
 			return addNetwork(a, b, c)
 		},
-		getNetwork: func(a userT, b guuid.UUID) (networkT, error) {
+		getNetwork: func(a userT, b uuid.UUID) (networkT, error) {
 			connMutex.RLock()
 			defer connMutex.RUnlock()
 			return getNetwork(a, b)
@@ -3329,7 +3329,7 @@ func initDB(
 			defer connMutex.RUnlock()
 			return dropRole(a, b, c)
 		},
-		showMember: func(a memberT, b guuid.UUID) (memberT, error) {
+		showMember: func(a memberT, b uuid.UUID) (memberT, error) {
 			connMutex.RLock()
 			defer connMutex.RUnlock()
 			return showMember(a, b)
@@ -3355,7 +3355,7 @@ func initDB(
 			defer connMutex.RUnlock()
 			return editMember(a, b)
 		},
-		dropMember: func(a memberT, b guuid.UUID) error {
+		dropMember: func(a memberT, b uuid.UUID) error {
 			connMutex.RLock()
 			defer connMutex.RUnlock()
 			return dropMember(a, b)
@@ -3391,12 +3391,12 @@ func initDB(
 			defer connMutex.RUnlock()
 			return setChannel(a, b)
 		},
-		endChannel: func(a memberT, b guuid.UUID) error {
+		endChannel: func(a memberT, b uuid.UUID) error {
 			connMutex.RLock()
 			defer connMutex.RUnlock()
 			return endChannel(a, b)
 		},
-		join: func(a memberT, b guuid.UUID) error {
+		join: func(a memberT, b uuid.UUID) error {
 			connMutex.RLock()
 			defer connMutex.RUnlock()
 			return join(a, b)
@@ -3408,7 +3408,7 @@ func initDB(
 		},
 		names: func(
 			a memberT,
-			b guuid.UUID,
+			b uuid.UUID,
 			callback func(memberT) error,
 		) error {
 			var (
@@ -3433,7 +3433,7 @@ func initDB(
 		},
 		allAfter: func(
 			a memberT,
-			b guuid.UUID,
+			b uuid.UUID,
 			callback func(eventT) error,
 		) error {
 			var (
@@ -3536,9 +3536,9 @@ func initListeners(
 func newStateMutable() stateMutableT {
 	var rwmutex sync.RWMutex
 	state := stateMutableDataT{
-		connections: map[guuid.UUID]*connectionT{},
-		users:       map[string][]guuid.UUID{},
-		members:     map[string]map[string][]guuid.UUID{},
+		connections: map[uuid.UUID]*connectionT{},
+		users:       map[string][]uuid.UUID{},
+		members:     map[string]map[string][]uuid.UUID{},
 	}
 	return stateMutableT{
 		/*
@@ -3570,7 +3570,7 @@ func newStateMutable() stateMutableT {
 			rwmutex.Lock()
 			defer rwmutex.Unlock()
 			if state.users[username] == nil {
-				state.users[username] = []guuid.UUID{}
+				state.users[username] = []uuid.UUID{}
 			}
 			state.users[username] = append(
 				state.users[username],
@@ -3587,7 +3587,7 @@ func newStateMutable() stateMutableT {
 			for _, channelName := range channelNames {
 				if state.members[channelName] == nil {
 					state.members[channelName] =
-						map[string][]guuid.UUID{}
+						map[string][]uuid.UUID{}
 				}
 				state.members[channelName][username] =
 					state.users[username]
@@ -3608,17 +3608,17 @@ func newStateMutable() stateMutableT {
 			}
 			return usernames
 		},
-		connections: func(username string) []guuid.UUID {
+		connections: func(username string) []uuid.UUID {
 			rwmutex.RLock()
 			defer rwmutex.RUnlock()
 			connections := make(
-				[]guuid.UUID,
+				[]uuid.UUID,
 				len(state.users[username]),
 			)
 			copy(connections, state.users[username])
 			return connections
 		},
-		connection: func(connectionID guuid.UUID) *connectionT {
+		connection: func(connectionID uuid.UUID) *connectionT {
 			rwmutex.RLock()
 			defer rwmutex.RUnlock()
 			return state.connections[connectionID]
@@ -3630,8 +3630,8 @@ func newStateMutable() stateMutableT {
 func newState() *stateT {
 	return &stateT{
 		members:     pds.NewMap[string, []string](nil),
-		users:       pds.NewMap[string, []guuid.UUID](nil),
-		connections: pds.NewMap[guuid.UUID, connectionT](nil),
+		users:       pds.NewMap[string, []uuid.UUID](nil),
+		connections: pds.NewMap[uuid.UUID, connectionT](nil),
 	}
 }
 
@@ -4444,7 +4444,7 @@ func processMessage(
 
 func handleConnection(papod papodT, conn net.Conn) {
 	connection := connectionT{
-		uuid: guuid.New(),
+		uuid: uuid.New(),
 		user: &userT{}, // TODO: SASL shenanigan probably goes here
 		conn: conn,
 	}
@@ -4527,7 +4527,7 @@ func (papod papodT) Start() error {
 			"cracha", cracha.Version,
 			"fiinha", fiinha.Version,
 			"golite", golite.Version,
-			"guuid",  guuid.Version,
+			"uuid",  uuid.Version,
 			"papod",  Version,
 		),
 	)
diff --git a/tests/papod.go b/tests/papod.go
index 283017a..3e82d82 100644
--- a/tests/papod.go
+++ b/tests/papod.go
@@ -13,7 +13,7 @@ import (
 	"time"
 
 	"golite"
-	"guuid"
+	"uuid"
 	g "gobang"
 )
 
@@ -25,7 +25,7 @@ type userChangeT struct{
 	user_id   int64
 	attribute string
 	valueStr  *string
-	valueBlob *guuid.UUID
+	valueBlob *uuid.UUID
 	valueBool *bool
 	op        bool
 }
@@ -86,10 +86,10 @@ func userChangesSQL(prefix string) string {
 	)
 }
 
-func makeUserChanges(db *sql.DB, prefix string) func(guuid.UUID) []userChangeT {
+func makeUserChanges(db *sql.DB, prefix string) func(uuid.UUID) []userChangeT {
 	q := userChangesSQL(prefix)
 
-	return func(userID guuid.UUID) []userChangeT {
+	return func(userID uuid.UUID) []userChangeT {
 		userChanges := []userChangeT{}
 		rows, err := db.Query(q, userID[:])
 		g.TErrorIf(err)
@@ -114,7 +114,7 @@ func makeUserChanges(db *sql.DB, prefix string) func(guuid.UUID) []userChangeT {
 			g.TErrorIf(err)
 
 			if value_bytes != nil {
-				valueBlob := guuid.UUID(value_bytes)
+				valueBlob := uuid.UUID(value_bytes)
 				userChange.valueBlob = &valueBlob
 			}
 
@@ -167,10 +167,10 @@ func networkChangesSQL(prefix string) string {
 func makeNetworkChanges(
 	db *sql.DB,
 	prefix string,
-) func(guuid.UUID) []networkChangeT {
+) func(uuid.UUID) []networkChangeT {
 	q := networkChangesSQL(prefix)
 
-	return func(networkID guuid.UUID) []networkChangeT {
+	return func(networkID uuid.UUID) []networkChangeT {
 		networkChanges := []networkChangeT{}
 		rows, err := db.Query(q, networkID[:])
 		g.TErrorIf(err)
@@ -411,7 +411,7 @@ func test_createUserStmt() {
 
 	g.Testing("userID's must be unique", func() {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		_, err1 := createUser(newUser)
@@ -425,7 +425,7 @@ func test_createUserStmt() {
 
 	g.Testing("a new user starts without a pictureID", func() {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -435,7 +435,7 @@ func test_createUserStmt() {
 
 	g.Testing("the database fills default and generated values", func() {
 		newUser := newUserT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			username:    "the username",
 			displayName: "the display name",
 		}
@@ -455,13 +455,13 @@ func test_createUserStmt() {
 		displayName := mkstring()
 
 		newUser1 := newUserT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			username:    username,
 			displayName: displayName,
 		}
 
 		newUser2 := newUserT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			username:    username,
 			displayName: displayName,
 		}
@@ -474,7 +474,7 @@ func test_createUserStmt() {
 
 	g.Testing("new user trigger inserts into *_user_changes", func() {
 		newUser := newUserT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			username:    mkstring(),
 			displayName: mkstring(),
 		}
@@ -570,13 +570,13 @@ func test_userByUUIDStmt() {
 
 
 	g.Testing("when a user doesn't exist, we get sql.ErrNoRows", func() {
-		_, err := userByUUID(guuid.New())
+		_, err := userByUUID(uuid.New())
 		g.TAssertEqual(err, sql.ErrNoRows)
 	})
 
 	g.Testing("after creating, we can retrieve the user", func() {
 		newUser := newUserT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			username:    mkstring(),
 			displayName: mkstring(),
 		}
@@ -597,7 +597,7 @@ func test_userByUUIDStmt() {
 
 	g.Testing("we can't retrieve a user once deleted",func() {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		_, err := createUser(newUser)
@@ -659,7 +659,7 @@ func test_updateUserStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			username:    mkstring(),
 			displayName: mkstring(),
 		}
@@ -683,7 +683,7 @@ func test_updateUserStmt() {
 
 	g.Testing("after updating, fetching gives us the newer data", func() {
 		newUser := newUserT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			username:    "first username",
 			displayName: "first display name",
 		}
@@ -729,7 +729,7 @@ func test_updateUserStmt() {
 		user1 := create()
 		g.TAssertEqual(user1.pictureID == nil, true)
 
-		pictureID := guuid.New()
+		pictureID := uuid.New()
 		user2 := user1
 		user2.pictureID = &pictureID
 		err = updateUser(user2)
@@ -757,7 +757,7 @@ func test_updateUserStmt() {
 
 		user2 := user1
 		user2.timestamp = user2.timestamp.Add(time.Minute * 1)
-		user2.uuid = guuid.New()
+		user2.uuid = uuid.New()
 		err := updateUser(user2)
 		g.TErrorIf(err)
 
@@ -777,7 +777,7 @@ func test_updateUserStmt() {
 
 	g.Testing("new username end up in *_user_changes when updated", func() {
 		newUser := newUserT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			username:    "first username",
 			displayName: "display name",
 		}
@@ -827,7 +827,7 @@ func test_updateUserStmt() {
 
 	g.Testing("displayName end up in *_user_changes when updated", func() {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 			username:    "username",
 			displayName: "first display name",
 		}
@@ -876,11 +876,11 @@ func test_updateUserStmt() {
 
 	g.Testing("pictureID end up in *_user_changes when updated", func() {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 			username:    "username",
 			displayName: "first display name",
 		}
-		pictureID := guuid.New()
+		pictureID := uuid.New()
 
 		user, err := createUser(newUser)
 		g.TErrorIf(err)
@@ -956,13 +956,13 @@ func test_deleteUserStmt() {
 
 
 	g.Testing("a user needs to exist to be deleted", func() {
-		err := deleteUser(guuid.New())
+		err := deleteUser(uuid.New())
 		g.TAssertEqual(err, sql.ErrNoRows)
 	})
 
 	g.Testing("error if deleted more than once", func() {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		_, err := createUser(newUser)
@@ -976,7 +976,7 @@ func test_deleteUserStmt() {
 
 	g.Testing("deletion triggers insertion into *_user_changes", func() {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -1066,7 +1066,7 @@ func test_addNetworkStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -1075,7 +1075,7 @@ func test_addNetworkStmt() {
 		return user
 	}
 
-	allMembers := func(actor memberT, networkID guuid.UUID) []memberT {
+	allMembers := func(actor memberT, networkID uuid.UUID) []memberT {
 		rows, err := members(actor)
 		g.TErrorIf(err)
 		defer rows.Close()
@@ -1097,13 +1097,13 @@ func test_addNetworkStmt() {
 		creator := create()
 
 		newNetwork := newNetworkT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			name:        "the network name",
 			description: "the network description",
 			type_:       NetworkType_Unlisted,
 		}
 
-		network, err := addNetwork(creator, newNetwork, guuid.New())
+		network, err := addNetwork(creator, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		g.TAssertEqual(network.id == 0, false)
@@ -1116,7 +1116,7 @@ func test_addNetworkStmt() {
 
 	g.Testing("the creator needs to exist", func() {
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Unlisted,
 		}
 
@@ -1124,7 +1124,7 @@ func test_addNetworkStmt() {
 			id: 1234,
 		}
 
-		_, err := addNetwork(virtualUser, newNetwork, guuid.New())
+		_, err := addNetwork(virtualUser, newNetwork, uuid.New())
 		g.TAssertEqual(
 			err.(golite.Error).ExtendedCode,
 			golite.ErrConstraintNotNull,
@@ -1135,13 +1135,13 @@ func test_addNetworkStmt() {
 		creator := create()
 
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			name:  mkstring(),
 			type_: NetworkType_Unlisted,
 		}
 
-		_, err1 := addNetwork(creator, newNetwork, guuid.New())
-		_, err2 := addNetwork(creator, newNetwork, guuid.New())
+		_, err1 := addNetwork(creator, newNetwork, uuid.New())
+		_, err2 := addNetwork(creator, newNetwork, uuid.New())
 		g.TErrorIf(err1)
 		g.TAssertEqual(
 			err2.(golite.Error).ExtendedCode,
@@ -1153,16 +1153,16 @@ func test_addNetworkStmt() {
 		creator := create()
 
 		newNetwork1 := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Unlisted,
 		}
 		newNetwork2 := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Unlisted,
 		}
 
-		_, err1 := addNetwork(creator, newNetwork1, guuid.New())
-		_, err2 := addNetwork(creator, newNetwork2, guuid.New())
+		_, err1 := addNetwork(creator, newNetwork1, uuid.New())
+		_, err2 := addNetwork(creator, newNetwork2, uuid.New())
 		g.TErrorIf(err1)
 		g.TErrorIf(err2)
 	})
@@ -1171,20 +1171,20 @@ func test_addNetworkStmt() {
 		creator := create()
 
 		newNetwork1 := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Unlisted,
 		}
 		newNetwork2 := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Unlisted,
 		}
 
-		_, err := addNetwork(creator, newNetwork1, guuid.New())
+		_, err := addNetwork(creator, newNetwork1, uuid.New())
 		g.TErrorIf(err)
 
 		err = deleteUser(creator.uuid)
 		g.TErrorIf(err)
-		_, err = addNetwork(creator, newNetwork2, guuid.New())
+		_, err = addNetwork(creator, newNetwork2, uuid.New())
 		g.TAssertEqual(
 			err.(golite.Error).ExtendedCode,
 			golite.ErrConstraintNotNull,
@@ -1195,13 +1195,13 @@ func test_addNetworkStmt() {
 		creator := create()
 
 		newNetwork := newNetworkT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			name:        "the network name",
 			description: "the network description",
 			type_:       NetworkType_Unlisted,
 		}
 
-		_, err := addNetwork(creator, newNetwork, guuid.New())
+		_, err := addNetwork(creator, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		changes := networkChanges(newNetwork.uuid)
@@ -1240,10 +1240,10 @@ func test_addNetworkStmt() {
 
 	g.Testing("the creator is automatically a member", func() {
 		creator  := create()
-		memberID := guuid.New()
+		memberID := uuid.New()
 
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Unlisted,
 		}
 
@@ -1261,10 +1261,10 @@ func test_addNetworkStmt() {
 
 	g.Testing(`the creator has "creator" and "admin" roles`, func() {
 		creator  := create()
-		memberID := guuid.New()
+		memberID := uuid.New()
 
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Unlisted,
 		}
 
@@ -1332,7 +1332,7 @@ func test_getNetworkStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -1343,11 +1343,11 @@ func test_getNetworkStmt() {
 
 	add := func(user userT, type_ NetworkType) (networkT, memberT) {
 		newNetwork := newNetworkT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 			type_: type_,
 		}
 
-		network, err := addNetwork(user, newNetwork, guuid.New())
+		network, err := addNetwork(user, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(user, network)
@@ -1367,7 +1367,7 @@ func test_getNetworkStmt() {
 	})
 
 	g.Testing("a network needs to exist", func() {
-		_, err := getNetwork(create(), guuid.New())
+		_, err := getNetwork(create(), uuid.New())
 		g.TAssertEqual(err, sql.ErrNoRows)
 	})
 
@@ -1429,7 +1429,7 @@ func test_getNetworkStmt() {
 		network, member := add(creator, NetworkType_Private)
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -1450,7 +1450,7 @@ func test_getNetworkStmt() {
 		network, member := add(creator, NetworkType_Public)
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -1502,7 +1502,7 @@ func test_getNetworkStmt() {
 		network, member := add(creator, NetworkType_Private)
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -1525,7 +1525,7 @@ func test_getNetworkStmt() {
 		network, member := add(creator, NetworkType_Private)
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -1588,7 +1588,7 @@ func test_networkEach() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -1597,13 +1597,13 @@ func test_networkEach() {
 		return user
 	}
 
-	add := func(user userT) guuid.UUID {
+	add := func(user userT) uuid.UUID {
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		_, err := addNetwork(user, newNetwork, guuid.New())
+		_, err := addNetwork(user, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		return newNetwork.uuid
@@ -1623,7 +1623,7 @@ func test_networkEach() {
 
 	g.Testing("the callback is called once for each entry", func() {
 		creator := create()
-		networkIDs := []guuid.UUID{
+		networkIDs := []uuid.UUID{
 			add(creator),
 			add(creator),
 			add(creator),
@@ -1633,7 +1633,7 @@ func test_networkEach() {
 		g.TErrorIf(err)
 		defer rows.Close()
 
-		var collectedIDs[]guuid.UUID
+		var collectedIDs[]uuid.UUID
 		err = networkEach(rows, func(network networkT) error {
 			collectedIDs = append(collectedIDs, network.uuid)
 			return nil
@@ -1766,7 +1766,7 @@ func test_networksStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -1777,11 +1777,11 @@ func test_networksStmt() {
 
 	add := func(user userT, type_ NetworkType) networkT {
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: type_,
 		}
 
-		network, err := addNetwork(user, newNetwork, guuid.New())
+		network, err := addNetwork(user, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		return network
@@ -1950,7 +1950,7 @@ func test_setNetworkStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -1961,10 +1961,10 @@ func test_setNetworkStmt() {
 
 	add := func(user userT) (networkT, memberT) {
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
-		memberID := guuid.New()
+		memberID := uuid.New()
 
 		network, err := addNetwork(user, newNetwork, memberID)
 		g.TErrorIf(err)
@@ -1998,7 +1998,7 @@ func test_setNetworkStmt() {
 		network, creatorMember := add(creator)
 		newMember := newMemberT{
 			userID:   admin.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -2024,7 +2024,7 @@ func test_setNetworkStmt() {
 		network, creatorMember := add(creator)
 		newMember := newMemberT{
 			userID:   admin.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -2061,7 +2061,7 @@ func test_setNetworkStmt() {
 		network, creatorMember := add(creator)
 		newMember := newMemberT{
 			userID:   admin.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -2092,7 +2092,7 @@ func test_setNetworkStmt() {
 		network, creatorMember := add(creator)
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -2144,7 +2144,7 @@ func test_setNetworkStmt() {
 		network1, member := add(creator)
 
 		network2 := network1
-		network2.uuid      = guuid.New()
+		network2.uuid      = uuid.New()
 		network2.timestamp = time.Time{}
 
 		err := setNetwork(member, network2)
@@ -2200,12 +2200,12 @@ func test_setNetworkStmt() {
 	g.Testing("updates do cause writes to changes table", func() {
 		creator := create()
 		newNetwork := newNetworkT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			name:        "first name",
 			description: "first description",
 			type_:       NetworkType_Public,
 		}
-		memberID := guuid.New()
+		memberID := uuid.New()
 
 		network, err := addNetwork(creator, newNetwork, memberID)
 		g.TErrorIf(err)
@@ -2337,7 +2337,7 @@ func test_nipNetworkStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -2348,11 +2348,11 @@ func test_nipNetworkStmt() {
 
 	add := func(user userT) (networkT, memberT) {
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(user, newNetwork, guuid.New())
+		network, err := addNetwork(user, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(user, network)
@@ -2438,7 +2438,7 @@ func test_nipNetworkStmt() {
 		_, creatorMember := add(create())
 		newMember := newMemberT{
 			userID:   admin.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -2457,7 +2457,7 @@ func test_nipNetworkStmt() {
 		_, creatorMember := add(create())
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -2476,7 +2476,7 @@ func test_nipNetworkStmt() {
 		_, member := add(create())
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -2584,7 +2584,7 @@ func test_membershipStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -2595,11 +2595,11 @@ func test_membershipStmt() {
 
 	add := func(user userT) networkT {
 		newNetwork := newNetworkT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 			type_: NetworkType_Private,
 		}
 
-		network, err := addNetwork(user, newNetwork, guuid.New())
+		network, err := addNetwork(user, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		return network
@@ -2665,7 +2665,7 @@ func test_membershipStmt() {
 		network := add(creator)
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: "a username",
 		}
 
@@ -2687,7 +2687,7 @@ func test_membershipStmt() {
 		network := add(creator)
 		newMember := newMemberT{
 			userID:   admin.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -2766,7 +2766,7 @@ func test_addMemberStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -2777,11 +2777,11 @@ func test_addMemberStmt() {
 
 	add := func(user userT) (networkT, memberT) {
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(user, newNetwork, guuid.New())
+		network, err := addNetwork(user, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(user, network)
@@ -2794,8 +2794,8 @@ func test_addMemberStmt() {
 	g.Testing("the user needs to exist", func() {
 		_, member := add(create())
 		newMember := newMemberT{
-			userID:   guuid.New(),
-			memberID: guuid.New(),
+			userID:   uuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -2812,12 +2812,12 @@ func test_addMemberStmt() {
 		_, member0 := add(create())
 		newMember1 := newMemberT{
 			userID:   user1.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 		newMember2 := newMemberT{
 			userID:   user2.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -2837,12 +2837,12 @@ func test_addMemberStmt() {
 		_, member0 := add(create())
 		newMember1 := newMemberT{
 			userID:   user1.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 		newMember2 := newMemberT{
 			userID:   user2.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -2862,12 +2862,12 @@ func test_addMemberStmt() {
 		_, member0 := add(create())
 		newMember1 := newMemberT{
 			userID:   user1.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 		newMember2 := newMemberT{
 			userID:   user2.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -2887,7 +2887,7 @@ func test_addMemberStmt() {
 		_, member := add(creator)
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -2905,7 +2905,7 @@ func test_addMemberStmt() {
 		user1   := create()
 		user2   := create()
 		_, member := add(creator)
-		memberID := guuid.New()
+		memberID := uuid.New()
 		newMember1 := newMemberT{
 			userID:   user1.uuid,
 			memberID: memberID,
@@ -2932,7 +2932,7 @@ func test_addMemberStmt() {
 		_, member := add(creator)
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -2952,7 +2952,7 @@ func test_addMemberStmt() {
 		_, member := add(creator)
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -3025,7 +3025,7 @@ func test_dropRoleStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -3036,11 +3036,11 @@ func test_dropRoleStmt() {
 
 	add := func(user userT) (networkT, memberT) {
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(user, newNetwork, guuid.New())
+		network, err := addNetwork(user, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(user, network)
@@ -3151,7 +3151,7 @@ func test_showMemberStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -3162,11 +3162,11 @@ func test_showMemberStmt() {
 
 	add := func(user userT) (networkT, memberT) {
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(user, newNetwork, guuid.New())
+		network, err := addNetwork(user, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(user, network)
@@ -3178,7 +3178,7 @@ func test_showMemberStmt() {
 
 	g.Testing("target member must exist", func() {
 		_, member := add(create())
-		_, err := showMember(member, guuid.New())
+		_, err := showMember(member, uuid.New())
 		g.TAssertEqual(err, sql.ErrNoRows)
 	})
 
@@ -3260,7 +3260,7 @@ func test_memberEach() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -3272,11 +3272,11 @@ func test_memberEach() {
 	add := func() memberT {
 		creator := create()
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(creator, newNetwork, guuid.New())
+		network, err := addNetwork(creator, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(creator, network)
@@ -3289,7 +3289,7 @@ func test_memberEach() {
 		user := create()
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -3311,7 +3311,7 @@ func test_memberEach() {
 		g.TErrorIf(err)
 		defer rows.Close()
 
-		memberIDs := []guuid.UUID{}
+		memberIDs := []uuid.UUID{}
 		err = memberEach(rows, func(member memberT) error {
 			memberIDs = append(memberIDs, member.uuid)
 			return nil
@@ -3324,7 +3324,7 @@ func test_memberEach() {
 	g.Testing("we halt if the callback returns an error", func() {
 		myErr  := errors.New("callback custom error")
 		member := add()
-		expectedIDs := []guuid.UUID{
+		expectedIDs := []uuid.UUID{
 			member.uuid,
 			addM(member, MemberStatus_Active).uuid,
 			addM(member, MemberStatus_Active).uuid,
@@ -3337,7 +3337,7 @@ func test_memberEach() {
 		g.TErrorIf(err)
 		defer rows.Close()
 
-		memberIDs := []guuid.UUID{}
+		memberIDs := []uuid.UUID{}
 		err = memberEach(rows, func(member memberT) error {
 			if len(memberIDs) == 3 {
 				return myErr
@@ -3405,7 +3405,7 @@ func test_membersStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -3417,11 +3417,11 @@ func test_membersStmt() {
 	add := func() memberT {
 		creator := create()
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(creator, newNetwork, guuid.New())
+		network, err := addNetwork(creator, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(creator, network)
@@ -3436,7 +3436,7 @@ func test_membersStmt() {
 		user := create()
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -3549,7 +3549,7 @@ func test_editMemberStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -3561,11 +3561,11 @@ func test_editMemberStmt() {
 	add := func() memberT {
 		user := create()
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(user, newNetwork, guuid.New())
+		network, err := addNetwork(user, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(user, network)
@@ -3642,7 +3642,7 @@ func test_addChannelStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -3654,11 +3654,11 @@ func test_addChannelStmt() {
 	add := func() memberT {
 		creator := create()
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(creator, newNetwork, guuid.New())
+		network, err := addNetwork(creator, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(creator, network)
@@ -3674,7 +3674,7 @@ func test_addChannelStmt() {
 		member := add()
 		publicName := "a-name"
 		newChannel := newChannelT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			publicName:  &publicName,
 			label:       "a-label",
 			description: "the description",
@@ -3697,7 +3697,7 @@ func test_addChannelStmt() {
 		member := add()
 		publicName := "another name"
 		newChannel := newChannelT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			publicName:  &publicName,
 			label:       "the label",
 			description: "the description",
@@ -3796,17 +3796,17 @@ func test_channelEach() {
 
 	add := func() memberT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
 		user, err := createUser(newUser)
 		g.TErrorIf(err)
 
-		network, err := addNetwork(user, newNetwork, guuid.New())
+		network, err := addNetwork(user, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(user, network)
@@ -3818,7 +3818,7 @@ func test_channelEach() {
 	addC := func(member memberT) channelT {
 		publicName := mkstring()
 		newChannel := newChannelT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			publicName:  &publicName,
 			label:       mkstring(),
 			description: mkstring(),
@@ -3956,7 +3956,7 @@ func test_channelsStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -3968,11 +3968,11 @@ func test_channelsStmt() {
 	add := func() memberT {
 		user := create()
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(user, newNetwork, guuid.New())
+		network, err := addNetwork(user, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(user, network)
@@ -3985,7 +3985,7 @@ func test_channelsStmt() {
 		user := create()
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -4001,7 +4001,7 @@ func test_channelsStmt() {
 		virtual bool,
 	) channelT {
 		newChannel := newChannelT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			publicName:  publicName,
 			label:       mkstring(),
 			description: mkstring(),
@@ -4151,7 +4151,7 @@ func test_setChannelStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -4163,11 +4163,11 @@ func test_setChannelStmt() {
 	add := func() memberT {
 		creator := create()
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(creator, newNetwork, guuid.New())
+		network, err := addNetwork(creator, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(creator, network)
@@ -4180,7 +4180,7 @@ func test_setChannelStmt() {
 		user := create()
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -4193,7 +4193,7 @@ func test_setChannelStmt() {
 	addC := func(actor memberT, description string) channelT {
 		publicName := mkstring()
 		newChannel := newChannelT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			publicName:  &publicName,
 			label:       mkstring(),
 			description: description,
@@ -4328,7 +4328,7 @@ func test_joinStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -4340,11 +4340,11 @@ func test_joinStmt() {
 	add := func() memberT {
 		creator := create()
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(creator, newNetwork, guuid.New())
+		network, err := addNetwork(creator, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(creator, network)
@@ -4357,7 +4357,7 @@ func test_joinStmt() {
 		user := create()
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -4369,7 +4369,7 @@ func test_joinStmt() {
 
 	addC := func(actor memberT, publicName *string, virtual bool) channelT {
 		newChannel := newChannelT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			publicName:  publicName,
 			label:       mkstring(),
 			description: mkstring(),
@@ -4395,7 +4395,7 @@ func test_joinStmt() {
 	})
 
 	g.Testing("target channel must exist", func() {
-		err := join(add(), guuid.New())
+		err := join(add(), uuid.New())
 		g.TAssertEqual(err, sql.ErrNoRows)
 	})
 
@@ -4535,7 +4535,7 @@ func test_partStmt() {
 
 	create := func() userT{
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -4547,11 +4547,11 @@ func test_partStmt() {
 	add := func() memberT {
 		creator := create()
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(creator, newNetwork, guuid.New())
+		network, err := addNetwork(creator, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(creator, network)
@@ -4564,7 +4564,7 @@ func test_partStmt() {
 		user := create()
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -4577,7 +4577,7 @@ func test_partStmt() {
 	addC := func(actor memberT, virtual bool) channelT {
 		publicName := "public name"
 		newChannel := newChannelT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			publicName:  &publicName,
 			label:       mkstring(),
 			description: mkstring(),
@@ -4703,7 +4703,7 @@ func test_addEventStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -4715,11 +4715,11 @@ func test_addEventStmt() {
 	add := func() memberT {
 		creator := create()
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(creator, newNetwork, guuid.New())
+		network, err := addNetwork(creator, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(creator, network)
@@ -4731,7 +4731,7 @@ func test_addEventStmt() {
 	addC := func(actor memberT) channelT {
 		publicName := mkstring()
 		newChannel := newChannelT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			publicName:  &publicName,
 			label:       mkstring(),
 			description: mkstring(),
@@ -4749,7 +4749,7 @@ func test_addEventStmt() {
 		creator  := add()
 		channel  := addC(creator)
 		newEvent := newEventT{
-			eventID:   guuid.New(),
+			eventID:   uuid.New(),
 			channelID: channel.uuid,
 			source: sourceT{
 				uuid:  creator.uuid,
@@ -4776,7 +4776,7 @@ func test_addEventStmt() {
 		creator  := add()
 		channel  := addC(creator)
 		newEvent := newEventT{
-			eventID:   guuid.New(),
+			eventID:   uuid.New(),
 			channelID: channel.uuid,
 			source: sourceT{
 				uuid: creator.uuid,
@@ -4797,18 +4797,18 @@ func test_addEventStmt() {
 
 	g.Testing("multiple messages can have the same source", func() {
 		source := sourceT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: SourceType_Logon,
 		}
 
 		newEvent1 := newEventT{
-			eventID:   guuid.New(),
+			eventID:   uuid.New(),
 			channelID: addC(add()).uuid,
 			source:    source,
 			type_:     EventType_UserMessage,
 		}
 		newEvent2 := newEventT{
-			eventID:   guuid.New(),
+			eventID:   uuid.New(),
 			channelID: addC(add()).uuid,
 			source:    source,
 			type_:     EventType_UserMessage,
@@ -4825,20 +4825,20 @@ func test_addEventStmt() {
 		payload := "a-payload"
 
 		newEvent1 := newEventT{
-			eventID:   guuid.New(),
+			eventID:   uuid.New(),
 			channelID: addC(add()).uuid,
 			source: sourceT{
-				uuid:  guuid.New(),
+				uuid:  uuid.New(),
 				type_: SourceType_Logon,
 			},
 			type_:   type_,
 			payload: payload,
 		}
 		newEvent2 := newEventT{
-			eventID:   guuid.New(),
+			eventID:   uuid.New(),
 			channelID: addC(add()).uuid,
 			source: sourceT{
-				uuid:  guuid.New(),
+				uuid:  uuid.New(),
 				type_: SourceType_Logon,
 			},
 			type_:   type_,
@@ -4903,7 +4903,7 @@ func test_eventEach() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -4915,11 +4915,11 @@ func test_eventEach() {
 	add := func() memberT {
 		creator := create()
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(creator, newNetwork, guuid.New())
+		network, err := addNetwork(creator, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(creator, network)
@@ -4931,7 +4931,7 @@ func test_eventEach() {
 	addC := func(actor memberT) channelT {
 		publicName := mkstring()
 		newChannel := newChannelT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			publicName:  &publicName,
 			label:       mkstring(),
 			description: mkstring(),
@@ -4945,13 +4945,13 @@ func test_eventEach() {
 	}
 
 	eventCount := 0
-	addE := func(channelID guuid.UUID) eventT {
+	addE := func(channelID uuid.UUID) eventT {
 		eventCount++
 		newEvent := newEventT{
 			// FIXME: missing eventID?
 			channelID: channelID,
 			source: sourceT{
-				uuid:  guuid.New(),
+				uuid:  uuid.New(),
 				type_: SourceType_Logon,
 			},
 			type_: EventType_UserMessage,
@@ -4966,7 +4966,7 @@ func test_eventEach() {
 
 
 	g.Testing("callback is not called when there is no message", func() {
-		eventID := guuid.New()
+		eventID := uuid.New()
 		member  := add()
 		rows, err := allAfter(member, eventID)
 		g.TErrorIf(err)
@@ -4982,7 +4982,7 @@ func test_eventEach() {
 	g.Testing("the callback is called once for each entry", func() {
 		return // FIXME
 
-		eventID := guuid.New()
+		eventID := uuid.New()
 		member  := add()
 		channel := addC(member)
 		expected := []eventT{
@@ -5008,7 +5008,7 @@ func test_eventEach() {
 	g.Testing("it halts if a callback returns an error", func() {
 		return // FIXME
 
-		eventID := guuid.New()
+		eventID := uuid.New()
 		member  := add()
 		channel := addC(member)
 		myErr   := errors.New("callback error early return")
@@ -5099,7 +5099,7 @@ func test_allAfterStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -5111,11 +5111,11 @@ func test_allAfterStmt() {
 	add := func() memberT {
 		creator := create()
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(creator, newNetwork, guuid.New())
+		network, err := addNetwork(creator, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(creator, network)
@@ -5127,7 +5127,7 @@ func test_allAfterStmt() {
 	addC := func(actor memberT) channelT {
 		publicName := mkstring()
 		newChannel := newChannelT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			publicName:  &publicName,
 			label:       mkstring(),
 			description: mkstring(),
@@ -5141,13 +5141,13 @@ func test_allAfterStmt() {
 	}
 
 	eventCount := 0
-	addE := func(channelID guuid.UUID) eventT {
+	addE := func(channelID uuid.UUID) eventT {
 		eventCount++
 		newEvent := newEventT{
-			eventID:   guuid.New(),
+			eventID:   uuid.New(),
 			channelID: channelID,
 			source: sourceT{
-				uuid:  guuid.New(),
+				uuid:  uuid.New(),
 				type_: SourceType_Logon,
 			},
 			type_:   EventType_UserMessage,
@@ -5161,7 +5161,7 @@ func test_allAfterStmt() {
 	}
 
 	// FIXME
-	allEvents := func(eventID guuid.UUID) []eventT {
+	allEvents := func(eventID uuid.UUID) []eventT {
 		rows, err := allAfter(memberT{}, eventID)
 		g.TErrorIf(err)
 		defer rows.Close()
@@ -5180,7 +5180,7 @@ func test_allAfterStmt() {
 	g.Testing("after joining the channel, there are no events", func() {
 		return // FIXME
 
-		eventID := guuid.New()
+		eventID := uuid.New()
 		member  := add()
 		channel := addC(member)
 
@@ -5198,7 +5198,7 @@ func test_allAfterStmt() {
 	g.Testing("we don't get events from other channels", func() {
 		return // FIXME
 
-		eventID  := guuid.New()
+		eventID  := uuid.New()
 		member   := add()
 		channel1 := addC(member)
 		channel2 := addC(member)
@@ -5219,7 +5219,7 @@ func test_allAfterStmt() {
 	g.Testing("as we change the reference point, the list changes", func() {
 		return // FIXME
 
-		eventID := guuid.New()
+		eventID := uuid.New()
 		member  := add()
 		channel := addC(member)