"German Red Garlic" now links back to the Johnny's page it came from, and pansy
knows how much is left.

Two modelling calls, both of which look like omissions unless stated.

The plant catalog stays FLAT — no species/variety hierarchy. A row in your
catalog just is the thing you plant; the built-in "Garlic" is a generic starting
point you clone. A hierarchy buys taxonomy nobody asked for and complicates
every join.

Inventory belongs to a PURCHASE, not to a variety. You might buy the same garlic
from two vendors in two years at two prices and two germination rates; quantity
columns on plants would collapse all of that into one number and lose it. So
lots get their own table, and owner_id sits on the lot rather than being
inherited from the plant — you can buy generic built-in Garlic from Johnny's and
the record is still yours alone. Lots are never shared along with a garden.

`remaining` is derived, never stored: quantity minus the summed effective count
of the active plantings attributed to the lot. The alternative — decrementing a
column when you plant — drifts the moment anything edits or removes a planting
behind its back, and once it has drifted there's no way to tell what the true
number was. Removing a plop gives the seed back with nothing having to remember
to. The usage query returns raw radius/count/spacing rather than a SUM, because
the effective-count formula lives in the service and reproducing it in SQL would
guarantee the two drift apart.

source_url is validated as http(s) with a host, on both plants and lots. It
renders as a clickable link, so that check is load-bearing rather than tidiness:
without it a stored javascript: URL becomes script execution the moment someone
clicks it. Schemeless and relative URLs are refused too — they'd resolve against
pansy's own origin, which is never what a vendor link means.

A planting's lot must be the actor's AND a lot of the plant being planted.
Attributing a garlic planting to a tomato lot would silently corrupt every
remaining count downstream, so it's refused rather than stored, and re-checked
on update in case a plant swap invalidated a previously-valid attribution.

Deleting a lot leaves its plantings alone with a null link: the plants really
were in the ground, whatever happened to the record of the packet.

Closes #50

Co-Authored-By: Claude Opus 4.8 (1M context) <[email protected]>
Claude-Session: https://claude.ai/code/session_01H3zbym8Doka2d7D48maSgZ

@@ -0,0 +57,4 @@
+	CostCents      json.RawMessage `json:"costCents"`
+	GerminationPct json.RawMessage `json:"germinationPct"`
+	Notes          *string         `json:"notes"`
+	Version        int64           `json:"version" binding:"required"`

@@ -0,0 +83,4 @@
+
+// parseNullable decodes any JSON value into (value, present) for a nullable
+// column. Absent → (nil, false); null → (nil, true); otherwise the decoded value.
+func parseNullable[T any](raw json.RawMessage) (*T, bool, error) {

@@ -150,1 +159,4 @@
 	}
+	// Re-checked on every update, not just when the lot changes: a plant swap can
+	// leave a previously-valid attribution pointing at a lot of the wrong variety.
+	if err := s.seedLotForPlanting(ctx, actorID, pl.SeedLotID, pl.PlantID); err != nil {

@@ -190,3 +187,1 @@
-		{Name: "x", Category: domain.CategoryHerb, SpacingCM: -5, Color: "#4a7c3f", Icon: "🌿"},        // negative spacing
-		{Name: "x", Category: domain.CategoryHerb, SpacingCM: 10, Color: "nope", Icon: "🌿"},           // bad color
-		{Name: "x", Category: domain.CategoryHerb, SpacingCM: 10, Color: "#4a7c3f", Icon: ""},          // empty icon
+		{Name: "", Category: domain.CategoryHerb, SpacingCM: 10, Color: "#4a7c3f", Icon: "🌿"},                                     // empty name

@@ -0,0 +90,4 @@
+// when you plant — drifts the moment anything edits or removes a planting behind
+// its back, and once it has drifted there is no way to tell what the true number
+// was. Attribution plus arithmetic can always be recomputed and audited.
+func (s *Service) fillRemaining(ctx context.Context, actorID int64, lots []domain.SeedLot) error {

@@ -0,0 +94,4 @@
+	if len(lots) == 0 {
+		return nil
+	}
+	uses, err := s.store.SeedLotUsage(ctx, actorID)

@@ -0,0 +108,4 @@
+	}
+	for i := range lots {
+		lots[i].Used = used[lots[i].ID]
+		lots[i].Remaining = lots[i].Quantity - lots[i].Used

@@ -0,0 +119,4 @@
+func (s *Service) ownSeedLot(ctx context.Context, actorID, lotID int64) (*domain.SeedLot, error) {
+	l, err := s.store.GetSeedLot(ctx, lotID)
+	if err != nil {
+		return nil, err // ErrNotFound

@@ -0,0 +128,4 @@
+}
+
+// GetSeedLot returns one of the actor's own lots, with Used/Remaining filled in.
+func (s *Service) GetSeedLot(ctx context.Context, actorID, lotID int64) (*domain.SeedLot, error) {

@@ -0,0 +143,4 @@
+// CreateSeedLot records a purchase owned by the actor. The plant must be one the
+// actor can see — a built-in or their own — since you can perfectly well buy
+// generic Garlic from a vendor.
+func (s *Service) CreateSeedLot(ctx context.Context, actorID int64, in SeedLotInput) (*domain.SeedLot, error) {

@@ -0,0 +165,4 @@
+	if err := finalizeSeedLot(l); err != nil {
+		return nil, err
+	}
+	return s.store.CreateSeedLot(ctx, l)

@@ -0,0 +169,4 @@
+}
+
+// UpdateSeedLot applies a partial, version-guarded patch to the actor's own lot.
+func (s *Service) UpdateSeedLot(ctx context.Context, actorID, lotID int64, patch SeedLotPatch, version int64) (*domain.SeedLot, error) {

@@ -0,0 +179,4 @@
+		return nil, err
+	}
+	l.Version = version
+	updated, err := s.store.UpdateSeedLot(ctx, l)

@@ -0,0 +187,4 @@
+	if ferr := s.fillRemaining(ctx, actorID, one); ferr != nil {
+		return nil, ferr
+	}
+	return &one[0], nil

@@ -0,0 +193,4 @@
+// DeleteSeedLot removes the actor's own lot. Plantings attributed to it survive
+// with a null link (ON DELETE SET NULL) — the plants really were in the ground,
+// whatever happened to the record of the packet.
+func (s *Service) DeleteSeedLot(ctx context.Context, actorID, lotID int64) error {

@@ -0,0 +204,4 @@
+// actor's, and must be a lot OF the plant being planted. Attributing a garlic
+// planting to a tomato lot is a data error that would silently corrupt every
+// remaining count downstream, so it's refused rather than stored.
+func (s *Service) seedLotForPlanting(ctx context.Context, actorID int64, lotID *int64, plantID int64) error {

@@ -0,0 +210,4 @@
+	}
+	l, err := s.ownSeedLot(ctx, actorID, *lotID)
+	if err != nil {
+		return domain.ErrInvalidInput // unknown or not yours: an invalid reference

@@ -0,0 +342,4 @@
+	}
+}
+
+func intPtr(v int) *int { return &v }

@@ -0,0 +60,4 @@
+// ListSeedLotsForOwner returns every lot the actor owns, newest purchase first
+// (undated lots last), then by id. Optionally narrowed to one plant. Always a
+// non-nil slice.
+func (d *DB) ListSeedLotsForOwner(ctx context.Context, ownerID int64, plantID *int64) ([]domain.SeedLot, error) {

@@ -0,0 +66,4 @@
+	if plantID != nil {
+		query += ` AND plant_id = ?`
+		args = append(args, *plantID)
+	}

@@ -0,0 +115,4 @@
+			return nil, gerr
+		}
+		return current, domain.ErrVersionConflict
+	}