Идентичность на ULID: download_infohash, guarded-дедуп, миграция (ulid-identity)

Все сущности переехали с INTEGER AUTOINCREMENT на TEXT ULID (lowercase,
internal/ident — единая точка генерации и разбора; oklog/ulid). Инфохэши
загрузки — множество (download_infohash, v1/v2 гибридных торрентов): дедуп
и сопоставление в поллинге по любому из хешей, magnet-парсер отдаёт оба
хеша гибридной ссылки, усечённый v2-хеш v2-only раздач не хранится.

Инвариант «не более одной активной загрузки на infohash» вместо снятого
unique-индекса держат guarded-методы store в одной write-транзакции
(_txlock=immediate): CreateDownloadIfNoActive (приём/adopt, с доносом
недостающих хешей), ActivateIfNoOtherActive (retry/recovery/relink, отказ
до побочных эффектов), guarded AddInfohashes; SetDownloadState отклоняет
терминал→активное как механический бэкстоп.

Миграция 0006 — первая Go-миграция goose: пересоздание таблиц при
включённых FK, backfill ULID с timestamp из created_at (хронология id
сохранена), разнос infohash, удаление idempotency_key. BREAKING: формат id
в URL/логах/Telegram, REST-поля id (string) и infohashes (список).

Новая конвенция docs/conventions/database.md (без числовых PK), корреляция
в логах grep'ом по голому ULID, ER-схема обновлена. Спеки: новая capability
identity, MODIFIED в state-reconciliation; change заархивирован. Пройдены
ревью дизайна и кода (по 8 углов), все находки исправлены с
регрессионными тестами.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

internal/ident/ident.go

@@ -0,0 +1,50 @@
+// Package ident — единственная точка генерации и разбора идентификаторов
+// домена. Идентификатор — ULID (26 символов Crockford base32), канонический
+// вид — lowercase; на входных границах (URL, формы) значение прогоняется
+// через Parse до обращения к хранилищу, потому что сравнение строк в SQLite
+// побайтовое.
+package ident
+
+import (
+	"crypto/rand"
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/oklog/ulid/v2"
+)
+
+// entropy — monotonic-источник: при равной миллисекунде timestamp'а энтропия
+// инкрементируется, так что id, выданные подряд, сохраняют порядок выдачи.
+var (
+	mu      sync.Mutex
+	entropy = ulid.Monotonic(rand.Reader, 0)
+)
+
+// NewID возвращает новый идентификатор (текущее время).
+func NewID() string {
+	return NewIDAt(time.Now())
+}
+
+// NewIDAt возвращает идентификатор с timestamp-частью из t. Используется
+// миграциями для бэкфилла: сортировка id сохраняет историческую хронологию
+// (created_at имеет секундное разрешение — равные метки упорядочивает
+// monotonic-энтропия в порядке вызовов).
+func NewIDAt(t time.Time) string {
+	mu.Lock()
+	defer mu.Unlock()
+	id := ulid.MustNew(ulid.Timestamp(t.UTC()), entropy)
+	return strings.ToLower(id.String())
+}
+
+// Parse валидирует внешний идентификатор и нормализует его к каноническому
+// lowercase-виду. Регистр входа не важен (base32 ULID case-insensitive).
+func Parse(s string) (string, error) {
+	s = strings.TrimSpace(s)
+	u, err := ulid.ParseStrict(strings.ToUpper(s))
+	if err != nil {
+		return "", fmt.Errorf("ident: parse %q: %w", s, err)
+	}
+	return strings.ToLower(u.String()), nil
+}

internal/ident/ident_test.go

@@ -0,0 +1,70 @@
+package ident
+
+import (
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestNewIDLowercaseAndValid(t *testing.T) {
+	id := NewID()
+	if len(id) != 26 {
+		t.Fatalf("len(%q) = %d, want 26", id, len(id))
+	}
+	if id != strings.ToLower(id) {
+		t.Fatalf("id %q is not lowercase", id)
+	}
+	if _, err := Parse(id); err != nil {
+		t.Fatalf("Parse(NewID()) failed: %v", err)
+	}
+}
+
+func TestNewIDSortedByIssueOrder(t *testing.T) {
+	prev := NewID()
+	for range 100 {
+		next := NewID()
+		if next <= prev {
+			t.Fatalf("ids out of order: %q then %q", prev, next)
+		}
+		prev = next
+	}
+}
+
+func TestNewIDAtEqualTimestampsKeepOrder(t *testing.T) {
+	ts := time.Date(2026, 7, 2, 12, 0, 0, 0, time.UTC)
+	prev := NewIDAt(ts)
+	for range 100 {
+		next := NewIDAt(ts) // одна и та же миллисекунда → monotonic-энтропия
+		if next <= prev {
+			t.Fatalf("ids out of order at equal timestamp: %q then %q", prev, next)
+		}
+		prev = next
+	}
+}
+
+func TestNewIDAtChronology(t *testing.T) {
+	older := NewIDAt(time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC))
+	newer := NewIDAt(time.Date(2026, 6, 1, 0, 0, 0, 0, time.UTC))
+	if older >= newer {
+		t.Fatalf("chronology broken: %q >= %q", older, newer)
+	}
+}
+
+func TestParseNormalizesCase(t *testing.T) {
+	id := NewID()
+	got, err := Parse(strings.ToUpper(id))
+	if err != nil {
+		t.Fatalf("Parse(upper) failed: %v", err)
+	}
+	if got != id {
+		t.Fatalf("Parse(upper) = %q, want %q", got, id)
+	}
+}
+
+func TestParseRejectsGarbage(t *testing.T) {
+	for _, bad := range []string{"", "abc", "abc!!!", "123", strings.Repeat("z", 26), strings.Repeat("a", 27)} {
+		if _, err := Parse(bad); err == nil {
+			t.Fatalf("Parse(%q) unexpectedly succeeded", bad)
+		}
+	}
+}