commit 4ebca3392d667b2047a7c804400ccb1d8af0ee81 · bretton.dev/coves

.claude/commands/fastcommit.md

···

       1
       1
       +
       Create new fast commit task

     

       2
       2
       +
       

     

       3
       3
       +
       This task uses the same logic as the commit task (.claude/commands/commit.md) but automatically selects the first suggested commit message without asking for confirmation.

     

       4
       4
       +
       

     

       5
       5
       +
           Generate 3 commit message suggestions following the same format as the commit task

     

       6
       6
       +
           Automatically use the first suggestion without asking the user

     

       7
       7
       +
           Immediately run git commit -m with the first message

     

       8
       8
       +
           All other behaviors remain the same as the commit task (format, package names, staged files only)

+4 -1

.gitignore

···

       42
       42
        
       

     

       43
       43
        
       # Temporary files

     

       44
       44
        
       *.tmp

     

       45
       45
       -
       *.temp
     

       45
       45
       +
       *.temp

     

       46
       46
       +
       

     

       47
       47
       +
       # Build artifacts

     

       48
       48
       +
       /validate-lexicon

+1 -1

cmd/validate-lexicon/main.go

···

       109
       109
        
       func loadSchemasWithDebug(catalog *lexicon.BaseCatalog, schemaPath string, verbose bool) error {

     

       110
       110
        
       	var schemaFiles []string

     

       111
       111
        
       

     

       112
       112
       -
       	// Collect all JSON schema filesred

     

       112
       112
       +
       	// Collect all JSON schema files

     

       113
       113
        
       	err := filepath.Walk(schemaPath, func(path string, info os.FileInfo, err error) error {

     

       114
       114
        
       		if err != nil {

     

       115
       115
        
       			return err

-19

internal/atproto/lexicon/social/coves/post/microblog.json

···

       42
       42
        
                     "maxLength": 100

     

       43
       43
        
                   }

     

       44
       44
        
                 },

     

       45
       45
       -
                 "mentions": {

     

       46
       46
       -
                   "type": "array",

     

       47
       47
       -
                   "description": "User mentions in the post",

     

       48
       48
       -
                   "items": {

     

       49
       49
       -
                     "type": "object",

     

       50
       50
       -
                     "required": ["did"],

     

       51
       51
       -
                     "properties": {

     

       52
       52
       -
                       "did": {

     

       53
       53
       -
                         "type": "string",

     

       54
       54
       -
                         "format": "did",

     

       55
       55
       -
                         "description": "DID of the mentioned user"

     

       56
       56
       -
                       },

     

       57
       57
       -
                       "handle": {

     

       58
       58
       -
                         "type": "string",

     

       59
       59
       -
                         "description": "Handle at time of mention"

     

       60
       60
       -
                       }

     

       61
       61
       -
                     }

     

       62
       62
       -
                   }

     

       63
       63
       -
                 },

     

       64
       45
        
                 "embed": {

     

       65
       46
        
                   "type": "union",

     

       66
       47
        
                   "description": "Embedded content (images, videos, links, quoted posts)",

+209

internal/atproto/lexicon/social/coves/richtext/README.md

···

       1
       1
       +
       # Rich Text Facets Documentation

     

       2
       2
       +
       

     

       3
       3
       +
       ## Overview

     

       4
       4
       +
       

     

       5
       5
       +
       Rich text facets provide a way to annotate ranges of text with formatting, mentions, links, and other features in the Coves platform. This implementation follows the AT Protocol standards while extending them with additional formatting options.

     

       6
       6
       +
       

     

       7
       7
       +
       ## UTF-8 Byte Counting

     

       8
       8
       +
       

     

       9
       9
       +
       **IMPORTANT**: All byte indices in facets use UTF-8 byte positions, not character positions or UTF-16 code units.

     

       10
       10
       +
       

     

       11
       11
       +
       ### Why UTF-8 Bytes?

     

       12
       12
       +
       

     

       13
       13
       +
       The AT Protocol uses UTF-8 byte counting to ensure consistent text indexing across all platforms and programming languages. This is crucial because:

     

       14
       14
       +
       

     

       15
       15
       +
       1. **Character counting varies** - What counts as one "character" differs between Unicode grapheme clusters, code points, and visual characters

     

       16
       16
       +
       2. **UTF-16 inconsistencies** - JavaScript uses UTF-16 internally, but other languages don't

     

       17
       17
       +
       3. **Network efficiency** - AT Protocol data is transmitted as UTF-8

     

       18
       18
       +
       

     

       19
       19
       +
       ### Calculating Byte Positions

     

       20
       20
       +
       

     

       21
       21
       +
       ```go

     

       22
       22
       +
       text := "Hello 👋 @alice!"

     

       23
       23
       +
       // Finding byte position of "@alice"

     

       24
       24
       +
       prefix := "Hello 👋 "

     

       25
       25
       +
       byteStart := len([]byte(prefix))  // 9 bytes (not 8 characters!)

     

       26
       26
       +
       byteEnd := byteStart + len([]byte("@alice"))  // 9 + 6 = 15

     

       27
       27
       +
       ```

     

       28
       28
       +
       

     

       29
       29
       +
       ### Common Pitfalls

     

       30
       30
       +
       

     

       31
       31
       +
       1. **Emoji can be multiple bytes**:

     

       32
       32
       +
          - "👋" = 4 bytes

     

       33
       33
       +
          - "👨‍👩‍👧‍👧" = 25 bytes (family emoji with zero-width joiners)

     

       34
       34
       +
       

     

       35
       35
       +
       2. **Non-ASCII text**:

     

       36
       36
       +
          - "café" = 5 bytes (é is 2 bytes)

     

       37
       37
       +
          - "Привет" = 12 bytes (each Cyrillic letter is 2 bytes)

     

       38
       38
       +
       

     

       39
       39
       +
       ## Facet Structure

     

       40
       40
       +
       

     

       41
       41
       +
       Each facet consists of:

     

       42
       42
       +
       - **index**: Byte range in the text

     

       43
       43
       +
       - **features**: Array of features applied to this range

     

       44
       44
       +
       

     

       45
       45
       +
       ```json

     

       46
       46
       +
       {

     

       47
       47
       +
         "index": {

     

       48
       48
       +
           "byteStart": 5,

     

       49
       49
       +
           "byteEnd": 11

     

       50
       50
       +
         },

     

       51
       51
       +
         "features": [

     

       52
       52
       +
           {

     

       53
       53
       +
             "$type": "social.coves.richtext.facet#mention",

     

       54
       54
       +
             "did": "did:plc:example123",

     

       55
       55
       +
             "handle": "alice.bsky.social"

     

       56
       56
       +
           }

     

       57
       57
       +
         ]

     

       58
       58
       +
       }

     

       59
       59
       +
       ```

     

       60
       60
       +
       

     

       61
       61
       +
       ## Supported Feature Types

     

       62
       62
       +
       

     

       63
       63
       +
       ### 1. Mention (`social.coves.richtext.facet#mention`)

     

       64
       64
       +
       For @mentions of users or !mentions of communities.

     

       65
       65
       +
       

     

       66
       66
       +
       ```json

     

       67
       67
       +
       {

     

       68
       68
       +
         "$type": "social.coves.richtext.facet#mention",

     

       69
       69
       +
         "did": "did:plc:example123",

     

       70
       70
       +
         "handle": "alice.bsky.social"  // Optional, for display

     

       71
       71
       +
       }

     

       72
       72
       +
       ```

     

       73
       73
       +
       

     

       74
       74
       +
       ### 2. Link (`social.coves.richtext.facet#link`)

     

       75
       75
       +
       For hyperlinks in text.

     

       76
       76
       +
       

     

       77
       77
       +
       ```json

     

       78
       78
       +
       {

     

       79
       79
       +
         "$type": "social.coves.richtext.facet#link",

     

       80
       80
       +
         "uri": "https://example.com"

     

       81
       81
       +
       }

     

       82
       82
       +
       ```

     

       83
       83
       +
       

     

       84
       84
       +
       ### 3. Bold (`social.coves.richtext.facet#bold`)

     

       85
       85
       +
       For **bold** text formatting.

     

       86
       86
       +
       

     

       87
       87
       +
       ```json

     

       88
       88
       +
       {

     

       89
       89
       +
         "$type": "social.coves.richtext.facet#bold"

     

       90
       90
       +
       }

     

       91
       91
       +
       ```

     

       92
       92
       +
       

     

       93
       93
       +
       ### 4. Italic (`social.coves.richtext.facet#italic`)

     

       94
       94
       +
       For *italic* text formatting.

     

       95
       95
       +
       

     

       96
       96
       +
       ```json

     

       97
       97
       +
       {

     

       98
       98
       +
         "$type": "social.coves.richtext.facet#italic"

     

       99
       99
       +
       }

     

       100
       100
       +
       ```

     

       101
       101
       +
       

     

       102
       102
       +
       ### 5. Strikethrough (`social.coves.richtext.facet#strikethrough`)

     

       103
       103
       +
       For ~~strikethrough~~ text formatting.

     

       104
       104
       +
       

     

       105
       105
       +
       ```json

     

       106
       106
       +
       {

     

       107
       107
       +
         "$type": "social.coves.richtext.facet#strikethrough"

     

       108
       108
       +
       }

     

       109
       109
       +
       ```

     

       110
       110
       +
       

     

       111
       111
       +
       ### 6. Spoiler (`social.coves.richtext.facet#spoiler`)

     

       112
       112
       +
       For hidden/spoiler text that requires user interaction to reveal.

     

       113
       113
       +
       

     

       114
       114
       +
       ```json

     

       115
       115
       +
       {

     

       116
       116
       +
         "$type": "social.coves.richtext.facet#spoiler",

     

       117
       117
       +
         "reason": "Movie spoiler"  // Optional

     

       118
       118
       +
       }

     

       119
       119
       +
       ```

     

       120
       120
       +
       

     

       121
       121
       +
       ## Examples

     

       122
       122
       +
       

     

       123
       123
       +
       ### Complete Post with Facets

     

       124
       124
       +
       

     

       125
       125
       +
       ```json

     

       126
       126
       +
       {

     

       127
       127
       +
         "text": "Check out **this** amazing post by @alice about ~secret stuff~!",

     

       128
       128
       +
         "facets": [

     

       129
       129
       +
           {

     

       130
       130
       +
             "index": {"byteStart": 10, "byteEnd": 18},

     

       131
       131
       +
             "features": [{"$type": "social.coves.richtext.facet#bold"}]

     

       132
       132
       +
           },

     

       133
       133
       +
           {

     

       134
       134
       +
             "index": {"byteStart": 36, "byteEnd": 42},

     

       135
       135
       +
             "features": [{

     

       136
       136
       +
               "$type": "social.coves.richtext.facet#mention",

     

       137
       137
       +
               "did": "did:plc:alice123",

     

       138
       138
       +
               "handle": "alice.coves.social"

     

       139
       139
       +
             }]

     

       140
       140
       +
           },

     

       141
       141
       +
           {

     

       142
       142
       +
             "index": {"byteStart": 49, "byteEnd": 62},

     

       143
       143
       +
             "features": [{

     

       144
       144
       +
               "$type": "social.coves.richtext.facet#spoiler",

     

       145
       145
       +
               "reason": "Plot details"

     

       146
       146
       +
             }]

     

       147
       147
       +
           }

     

       148
       148
       +
         ]

     

       149
       149
       +
       }

     

       150
       150
       +
       ```

     

       151
       151
       +
       

     

       152
       152
       +
       ### Multiple Features on Same Range

     

       153
       153
       +
       

     

       154
       154
       +
       Text can have multiple formatting features:

     

       155
       155
       +
       

     

       156
       156
       +
       ```json

     

       157
       157
       +
       {

     

       158
       158
       +
         "text": "This is ***really*** important!",

     

       159
       159
       +
         "facets": [

     

       160
       160
       +
           {

     

       161
       161
       +
             "index": {"byteStart": 8, "byteEnd": 20},

     

       162
       162
       +
             "features": [

     

       163
       163
       +
               {"$type": "social.coves.richtext.facet#bold"},

     

       164
       164
       +
               {"$type": "social.coves.richtext.facet#italic"}

     

       165
       165
       +
             ]

     

       166
       166
       +
           }

     

       167
       167
       +
         ]

     

       168
       168
       +
       }

     

       169
       169
       +
       ```

     

       170
       170
       +
       

     

       171
       171
       +
       ## Best Practices

     

       172
       172
       +
       

     

       173
       173
       +
       1. **Validate byte ranges**: Ensure byteEnd > byteStart and both are within text bounds

     

       174
       174
       +
       2. **Sort facets**: Order facets by byteStart for easier processing

     

       175
       175
       +
       3. **Handle overlaps**: Multiple facets can overlap - render them in a sensible order

     

       176
       176
       +
       4. **Validate features**: Each feature must have a valid `$type` field

     

       177
       177
       +
       5. **UTF-8 safety**: Always calculate bytes using UTF-8 encoding, not string length

     

       178
       178
       +
       

     

       179
       179
       +
       ## Integration with Bluesky

     

       180
       180
       +
       

     

       181
       181
       +
       When federating content from Bluesky:

     

       182
       182
       +
       - Bluesky uses `app.bsky.richtext.facet` with similar structure

     

       183
       183
       +
       - Convert their facet types to Coves equivalents

     

       184
       184
       +
       - Preserve byte indices (they also use UTF-8)

     

       185
       185
       +
       

     

       186
       186
       +
       ## Client Implementation Notes

     

       187
       187
       +
       

     

       188
       188
       +
       For web clients:

     

       189
       189
       +
       ```javascript

     

       190
       190
       +
       // Converting JavaScript string index to UTF-8 bytes

     

       191
       191
       +
       const textEncoder = new TextEncoder();

     

       192
       192
       +
       const bytes = textEncoder.encode(text.substring(0, charIndex));

     

       193
       193
       +
       const byteIndex = bytes.length;

     

       194
       194
       +
       ```

     

       195
       195
       +
       

     

       196
       196
       +
       For Go implementations:

     

       197
       197
       +
       ```go

     

       198
       198
       +
       // Already UTF-8 native

     

       199
       199
       +
       byteIndex := len(text[:runeIndex])

     

       200
       200
       +
       ```

     

       201
       201
       +
       

     

       202
       202
       +
       ## Validation

     

       203
       203
       +
       

     

       204
       204
       +
       Always validate:

     

       205
       205
       +
       1. Byte indices are non-negative integers

     

       206
       206
       +
       2. ByteEnd > byteStart

     

       207
       207
       +
       3. Byte ranges don't exceed text length

     

       208
       208
       +
       4. Each feature has required fields

     

       209
       209
       +
       5. `$type` values are recognized

+36 -5

internal/atproto/lexicon/social/coves/richtext/facet.json

···

       48
       48
        
           "mention": {

     

       49
       49
        
             "type": "object",

     

       50
       50
        
             "description": "Facet feature for user or community mentions",

     

       51
       51
       -
             "required": ["did"],

     

       51
       51
       +
             "required": ["$type", "did"],

     

       52
       52
        
             "properties": {

     

       53
       53
       +
               "$type": {

     

       54
       54
       +
                 "type": "string",

     

       55
       55
       +
                 "const": "social.coves.richtext.facet#mention"

     

       56
       56
       +
               },

     

       53
       57
        
               "did": {

     

       54
       58
        
                 "type": "string",

     

       55
       59
        
                 "format": "did",

     
···

       64
       68
        
           "link": {

     

       65
       69
        
             "type": "object",

     

       66
       70
        
             "description": "Facet feature for hyperlinks",

     

       67
       67
       -
             "required": ["uri"],

     

       71
       71
       +
             "required": ["$type", "uri"],

     

       68
       72
        
             "properties": {

     

       73
       73
       +
               "$type": {

     

       74
       74
       +
                 "type": "string",

     

       75
       75
       +
                 "const": "social.coves.richtext.facet#link"

     

       76
       76
       +
               },

     

       69
       77
        
               "uri": {

     

       70
       78
        
                 "type": "string",

     

       71
       79
        
                 "format": "uri",

     
···

       76
       84
        
           "bold": {

     

       77
       85
        
             "type": "object",

     

       78
       86
        
             "description": "Bold text formatting",

     

       79
       79
       -
             "properties": {}

     

       87
       87
       +
             "required": ["$type"],

     

       88
       88
       +
             "properties": {

     

       89
       89
       +
               "$type": {

     

       90
       90
       +
                 "type": "string",

     

       91
       91
       +
                 "const": "social.coves.richtext.facet#bold"

     

       92
       92
       +
               }

     

       93
       93
       +
             }

     

       80
       94
        
           },

     

       81
       95
        
           "italic": {

     

       82
       96
        
             "type": "object",

     

       83
       97
        
             "description": "Italic text formatting",

     

       84
       84
       -
             "properties": {}

     

       98
       98
       +
             "required": ["$type"],

     

       99
       99
       +
             "properties": {

     

       100
       100
       +
               "$type": {

     

       101
       101
       +
                 "type": "string",

     

       102
       102
       +
                 "const": "social.coves.richtext.facet#italic"

     

       103
       103
       +
               }

     

       104
       104
       +
             }

     

       85
       105
        
           },

     

       86
       106
        
           "strikethrough": {

     

       87
       107
        
             "type": "object",

     

       88
       108
        
             "description": "Strikethrough text formatting",

     

       89
       89
       -
             "properties": {}

     

       109
       109
       +
             "required": ["$type"],

     

       110
       110
       +
             "properties": {

     

       111
       111
       +
               "$type": {

     

       112
       112
       +
                 "type": "string",

     

       113
       113
       +
                 "const": "social.coves.richtext.facet#strikethrough"

     

       114
       114
       +
               }

     

       115
       115
       +
             }

     

       90
       116
        
           },

     

       91
       117
        
           "spoiler": {

     

       92
       118
        
             "type": "object",

     

       93
       119
        
             "description": "Hidden/spoiler text that requires user interaction to reveal",

     

       120
       120
       +
             "required": ["$type"],

     

       94
       121
        
             "properties": {

     

       122
       122
       +
               "$type": {

     

       123
       123
       +
                 "type": "string",

     

       124
       124
       +
                 "const": "social.coves.richtext.facet#spoiler"

     

       125
       125
       +
               },

     

       95
       126
        
               "reason": {

     

       96
       127
        
                 "type": "string",

     

       97
       128
        
                 "maxLength": 128,

+351

internal/atproto/lexicon/social/coves/richtext/facet_test.go

···

       1
       1
       +
       package richtext

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       	"testing"

     

       6
       6
       +
       )

     

       7
       7
       +
       

     

       8
       8
       +
       // TestFacetStructure tests the basic structure of facets

     

       9
       9
       +
       func TestFacetStructure(t *testing.T) {

     

       10
       10
       +
       	tests := []struct {

     

       11
       11
       +
       		name    string

     

       12
       12
       +
       		facet   string

     

       13
       13
       +
       		wantErr bool

     

       14
       14
       +
       	}{

     

       15
       15
       +
       		{

     

       16
       16
       +
       			name: "valid mention facet",

     

       17
       17
       +
       			facet: `{

     

       18
       18
       +
       				"index": {

     

       19
       19
       +
       					"byteStart": 5,

     

       20
       20
       +
       					"byteEnd": 18

     

       21
       21
       +
       				},

     

       22
       22
       +
       				"features": [{

     

       23
       23
       +
       					"$type": "social.coves.richtext.facet#mention",

     

       24
       24
       +
       					"did": "did:plc:example123",

     

       25
       25
       +
       					"handle": "alice.bsky.social"

     

       26
       26
       +
       				}]

     

       27
       27
       +
       			}`,

     

       28
       28
       +
       			wantErr: false,

     

       29
       29
       +
       		},

     

       30
       30
       +
       		{

     

       31
       31
       +
       			name: "valid link facet",

     

       32
       32
       +
       			facet: `{

     

       33
       33
       +
       				"index": {

     

       34
       34
       +
       					"byteStart": 10,

     

       35
       35
       +
       					"byteEnd": 35

     

       36
       36
       +
       				},

     

       37
       37
       +
       				"features": [{

     

       38
       38
       +
       					"$type": "social.coves.richtext.facet#link",

     

       39
       39
       +
       					"uri": "https://example.com"

     

       40
       40
       +
       				}]

     

       41
       41
       +
       			}`,

     

       42
       42
       +
       			wantErr: false,

     

       43
       43
       +
       		},

     

       44
       44
       +
       		{

     

       45
       45
       +
       			name: "valid formatting facet",

     

       46
       46
       +
       			facet: `{

     

       47
       47
       +
       				"index": {

     

       48
       48
       +
       					"byteStart": 0,

     

       49
       49
       +
       					"byteEnd": 5

     

       50
       50
       +
       				},

     

       51
       51
       +
       				"features": [{

     

       52
       52
       +
       					"$type": "social.coves.richtext.facet#bold"

     

       53
       53
       +
       				}]

     

       54
       54
       +
       			}`,

     

       55
       55
       +
       			wantErr: false,

     

       56
       56
       +
       		},

     

       57
       57
       +
       		{

     

       58
       58
       +
       			name: "multiple features on same range",

     

       59
       59
       +
       			facet: `{

     

       60
       60
       +
       				"index": {

     

       61
       61
       +
       					"byteStart": 0,

     

       62
       62
       +
       					"byteEnd": 10

     

       63
       63
       +
       				},

     

       64
       64
       +
       				"features": [

     

       65
       65
       +
       					{"$type": "social.coves.richtext.facet#bold"},

     

       66
       66
       +
       					{"$type": "social.coves.richtext.facet#italic"}

     

       67
       67
       +
       				]

     

       68
       68
       +
       			}`,

     

       69
       69
       +
       			wantErr: false,

     

       70
       70
       +
       		},

     

       71
       71
       +
       	}

     

       72
       72
       +
       

     

       73
       73
       +
       	for _, tt := range tests {

     

       74
       74
       +
       		t.Run(tt.name, func(t *testing.T) {

     

       75
       75
       +
       			var facet map[string]interface{}

     

       76
       76
       +
       			err := json.Unmarshal([]byte(tt.facet), &facet)

     

       77
       77
       +
       			if err != nil {

     

       78
       78
       +
       				if !tt.wantErr {

     

       79
       79
       +
       					t.Errorf("json.Unmarshal() unexpected error = %v", err)

     

       80
       80
       +
       				}

     

       81
       81
       +
       				return

     

       82
       82
       +
       			}

     

       83
       83
       +
       			

     

       84
       84
       +
       			// Basic validation

     

       85
       85
       +
       			if _, hasIndex := facet["index"]; !hasIndex && !tt.wantErr {

     

       86
       86
       +
       				t.Error("facet missing required 'index' field")

     

       87
       87
       +
       			}

     

       88
       88
       +
       			if _, hasFeatures := facet["features"]; !hasFeatures && !tt.wantErr {

     

       89
       89
       +
       				t.Error("facet missing required 'features' field")

     

       90
       90
       +
       			}

     

       91
       91
       +
       		})

     

       92
       92
       +
       	}

     

       93
       93
       +
       }

     

       94
       94
       +
       

     

       95
       95
       +
       // TestUTF8ByteCounting tests proper UTF-8 byte counting for facets

     

       96
       96
       +
       func TestUTF8ByteCounting(t *testing.T) {

     

       97
       97
       +
       	tests := []struct {

     

       98
       98
       +
       		name      string

     

       99
       99
       +
       		text      string

     

       100
       100
       +
       		substring string

     

       101
       101
       +
       		wantStart int

     

       102
       102
       +
       		wantEnd   int

     

       103
       103
       +
       	}{

     

       104
       104
       +
       		{

     

       105
       105
       +
       			name:      "ASCII text",

     

       106
       106
       +
       			text:      "Hello @alice!",

     

       107
       107
       +
       			substring: "@alice",

     

       108
       108
       +
       			wantStart: 6,

     

       109
       109
       +
       			wantEnd:   12,

     

       110
       110
       +
       		},

     

       111
       111
       +
       		{

     

       112
       112
       +
       			name:      "Emoji in text",

     

       113
       113
       +
       			text:      "Hi 👋 @alice!",

     

       114
       114
       +
       			substring: "@alice",

     

       115
       115
       +
       			wantStart: 8,  // "Hi " (3) + "👋" (4) + " " (1) = 8

     

       116
       116
       +
       			wantEnd:   14, // 8 + 6 = 14

     

       117
       117
       +
       		},

     

       118
       118
       +
       		{

     

       119
       119
       +
       			name:      "Complex emoji (family)",

     

       120
       120
       +
       			text:      "Family: 👨‍👩‍👧‍👧 @alice",

     

       121
       121
       +
       			substring: "@alice",

     

       122
       122
       +
       			wantStart: 34, // "Family: " (8) + complex emoji (25) + " " (1) = 34

     

       123
       123
       +
       			wantEnd:   40, // 34 + 6 = 40

     

       124
       124
       +
       		},

     

       125
       125
       +
       		{

     

       126
       126
       +
       			name:      "Multibyte characters",

     

       127
       127
       +
       			text:      "Привет @alice!",

     

       128
       128
       +
       			substring: "@alice",

     

       129
       129
       +
       			wantStart: 13, // Cyrillic "Привет " = 12 bytes + 1 space = 13

     

       130
       130
       +
       			wantEnd:   19, // 13 + 6 = 19

     

       131
       131
       +
       		},

     

       132
       132
       +
       		{

     

       133
       133
       +
       			name:      "Mixed content",

     

       134
       134
       +
       			text:      "Test 测试 @alice done",

     

       135
       135
       +
       			substring: "@alice",

     

       136
       136
       +
       			wantStart: 12, // "Test " (5) + "测试" (6) + " " (1) = 12

     

       137
       137
       +
       			wantEnd:   18, // 12 + 6 = 18

     

       138
       138
       +
       		},

     

       139
       139
       +
       	}

     

       140
       140
       +
       

     

       141
       141
       +
       	for _, tt := range tests {

     

       142
       142
       +
       		t.Run(tt.name, func(t *testing.T) {

     

       143
       143
       +
       			// Find byte positions using strings.Index (which works on bytes)

     

       144
       144
       +
       			idx := -1

     

       145
       145
       +
       			for i := 0; i < len(tt.text); i++ {

     

       146
       146
       +
       				if i+len(tt.substring) <= len(tt.text) && tt.text[i:i+len(tt.substring)] == tt.substring {

     

       147
       147
       +
       					idx = i

     

       148
       148
       +
       					break

     

       149
       149
       +
       				}

     

       150
       150
       +
       			}

     

       151
       151
       +
       			

     

       152
       152
       +
       			if idx == -1 {

     

       153
       153
       +
       				t.Fatalf("substring %q not found in text %q", tt.substring, tt.text)

     

       154
       154
       +
       			}

     

       155
       155
       +
       			

     

       156
       156
       +
       			// Calculate byte positions

     

       157
       157
       +
       			startByte := len([]byte(tt.text[:idx]))

     

       158
       158
       +
       			endByte := startByte + len([]byte(tt.substring))

     

       159
       159
       +
       

     

       160
       160
       +
       			if startByte != tt.wantStart {

     

       161
       161
       +
       				t.Errorf("ByteStart = %d, want %d", startByte, tt.wantStart)

     

       162
       162
       +
       			}

     

       163
       163
       +
       			if endByte != tt.wantEnd {

     

       164
       164
       +
       				t.Errorf("ByteEnd = %d, want %d", endByte, tt.wantEnd)

     

       165
       165
       +
       			}

     

       166
       166
       +
       		})

     

       167
       167
       +
       	}

     

       168
       168
       +
       }

     

       169
       169
       +
       

     

       170
       170
       +
       // TestOverlappingFacets tests validation of overlapping facet ranges

     

       171
       171
       +
       func TestOverlappingFacets(t *testing.T) {

     

       172
       172
       +
       	tests := []struct {

     

       173
       173
       +
       		name         string

     

       174
       174
       +
       		facets       []map[string]interface{}

     

       175
       175
       +
       		expectError  bool

     

       176
       176
       +
       		description  string

     

       177
       177
       +
       	}{

     

       178
       178
       +
       		{

     

       179
       179
       +
       			name: "non-overlapping facets",

     

       180
       180
       +
       			facets: []map[string]interface{}{

     

       181
       181
       +
       				{

     

       182
       182
       +
       					"index": map[string]int{

     

       183
       183
       +
       						"byteStart": 0,

     

       184
       184
       +
       						"byteEnd":   5,

     

       185
       185
       +
       					},

     

       186
       186
       +
       				},

     

       187
       187
       +
       				{

     

       188
       188
       +
       					"index": map[string]int{

     

       189
       189
       +
       						"byteStart": 10,

     

       190
       190
       +
       						"byteEnd":   15,

     

       191
       191
       +
       					},

     

       192
       192
       +
       				},

     

       193
       193
       +
       			},

     

       194
       194
       +
       			expectError:  false,

     

       195
       195
       +
       			description:  "Facets with non-overlapping ranges should be valid",

     

       196
       196
       +
       		},

     

       197
       197
       +
       		{

     

       198
       198
       +
       			name: "exact same range",

     

       199
       199
       +
       			facets: []map[string]interface{}{

     

       200
       200
       +
       				{

     

       201
       201
       +
       					"index": map[string]int{

     

       202
       202
       +
       						"byteStart": 5,

     

       203
       203
       +
       						"byteEnd":   10,

     

       204
       204
       +
       					},

     

       205
       205
       +
       				},

     

       206
       206
       +
       				{

     

       207
       207
       +
       					"index": map[string]int{

     

       208
       208
       +
       						"byteStart": 5,

     

       209
       209
       +
       						"byteEnd":   10,

     

       210
       210
       +
       					},

     

       211
       211
       +
       				},

     

       212
       212
       +
       			},

     

       213
       213
       +
       			expectError:  false,

     

       214
       214
       +
       			description:  "Multiple facets on the same range are allowed (e.g., bold + italic)",

     

       215
       215
       +
       		},

     

       216
       216
       +
       		{

     

       217
       217
       +
       			name: "nested ranges",

     

       218
       218
       +
       			facets: []map[string]interface{}{

     

       219
       219
       +
       				{

     

       220
       220
       +
       					"index": map[string]int{

     

       221
       221
       +
       						"byteStart": 0,

     

       222
       222
       +
       						"byteEnd":   20,

     

       223
       223
       +
       					},

     

       224
       224
       +
       				},

     

       225
       225
       +
       				{

     

       226
       226
       +
       					"index": map[string]int{

     

       227
       227
       +
       						"byteStart": 5,

     

       228
       228
       +
       						"byteEnd":   15,

     

       229
       229
       +
       					},

     

       230
       230
       +
       				},

     

       231
       231
       +
       			},

     

       232
       232
       +
       			expectError:  false,

     

       233
       233
       +
       			description:  "Nested facet ranges are allowed",

     

       234
       234
       +
       		},

     

       235
       235
       +
       		{

     

       236
       236
       +
       			name: "partial overlap",

     

       237
       237
       +
       			facets: []map[string]interface{}{

     

       238
       238
       +
       				{

     

       239
       239
       +
       					"index": map[string]int{

     

       240
       240
       +
       						"byteStart": 0,

     

       241
       241
       +
       						"byteEnd":   10,

     

       242
       242
       +
       					},

     

       243
       243
       +
       				},

     

       244
       244
       +
       				{

     

       245
       245
       +
       					"index": map[string]int{

     

       246
       246
       +
       						"byteStart": 5,

     

       247
       247
       +
       						"byteEnd":   15,

     

       248
       248
       +
       					},

     

       249
       249
       +
       				},

     

       250
       250
       +
       			},

     

       251
       251
       +
       			expectError:  false,

     

       252
       252
       +
       			description:  "Partially overlapping facets are allowed",

     

       253
       253
       +
       		},

     

       254
       254
       +
       	}

     

       255
       255
       +
       

     

       256
       256
       +
       	for _, tt := range tests {

     

       257
       257
       +
       		t.Run(tt.name, func(t *testing.T) {

     

       258
       258
       +
       			// For now, we're not implementing overlap validation

     

       259
       259
       +
       			// as it's allowed in AT Protocol

     

       260
       260
       +
       			// This test documents the expected behavior

     

       261
       261
       +
       			if tt.expectError {

     

       262
       262
       +
       				t.Skip("Overlap validation not implemented - all overlaps are currently allowed")

     

       263
       263
       +
       			}

     

       264
       264
       +
       		})

     

       265
       265
       +
       	}

     

       266
       266
       +
       }

     

       267
       267
       +
       

     

       268
       268
       +
       // TestFacetFeatureTypes tests all supported facet feature types

     

       269
       269
       +
       func TestFacetFeatureTypes(t *testing.T) {

     

       270
       270
       +
       	featureTypes := []struct {

     

       271
       271
       +
       		name     string

     

       272
       272
       +
       		typeName string

     

       273
       273
       +
       		feature  map[string]interface{}

     

       274
       274
       +
       	}{

     

       275
       275
       +
       		{

     

       276
       276
       +
       			name:     "mention",

     

       277
       277
       +
       			typeName: "social.coves.richtext.facet#mention",

     

       278
       278
       +
       			feature: map[string]interface{}{

     

       279
       279
       +
       				"$type":  "social.coves.richtext.facet#mention",

     

       280
       280
       +
       				"did":    "did:plc:example123",

     

       281
       281
       +
       				"handle": "alice.bsky.social",

     

       282
       282
       +
       			},

     

       283
       283
       +
       		},

     

       284
       284
       +
       		{

     

       285
       285
       +
       			name:     "link",

     

       286
       286
       +
       			typeName: "social.coves.richtext.facet#link",

     

       287
       287
       +
       			feature: map[string]interface{}{

     

       288
       288
       +
       				"$type": "social.coves.richtext.facet#link",

     

       289
       289
       +
       				"uri":   "https://example.com",

     

       290
       290
       +
       			},

     

       291
       291
       +
       		},

     

       292
       292
       +
       		{

     

       293
       293
       +
       			name:     "bold",

     

       294
       294
       +
       			typeName: "social.coves.richtext.facet#bold",

     

       295
       295
       +
       			feature: map[string]interface{}{

     

       296
       296
       +
       				"$type": "social.coves.richtext.facet#bold",

     

       297
       297
       +
       			},

     

       298
       298
       +
       		},

     

       299
       299
       +
       		{

     

       300
       300
       +
       			name:     "italic",

     

       301
       301
       +
       			typeName: "social.coves.richtext.facet#italic",

     

       302
       302
       +
       			feature: map[string]interface{}{

     

       303
       303
       +
       				"$type": "social.coves.richtext.facet#italic",

     

       304
       304
       +
       			},

     

       305
       305
       +
       		},

     

       306
       306
       +
       		{

     

       307
       307
       +
       			name:     "strikethrough",

     

       308
       308
       +
       			typeName: "social.coves.richtext.facet#strikethrough",

     

       309
       309
       +
       			feature: map[string]interface{}{

     

       310
       310
       +
       				"$type": "social.coves.richtext.facet#strikethrough",

     

       311
       311
       +
       			},

     

       312
       312
       +
       		},

     

       313
       313
       +
       		{

     

       314
       314
       +
       			name:     "spoiler",

     

       315
       315
       +
       			typeName: "social.coves.richtext.facet#spoiler",

     

       316
       316
       +
       			feature: map[string]interface{}{

     

       317
       317
       +
       				"$type":  "social.coves.richtext.facet#spoiler",

     

       318
       318
       +
       				"reason": "Plot spoiler",

     

       319
       319
       +
       			},

     

       320
       320
       +
       		},

     

       321
       321
       +
       	}

     

       322
       322
       +
       

     

       323
       323
       +
       	for _, ft := range featureTypes {

     

       324
       324
       +
       		t.Run(ft.name, func(t *testing.T) {

     

       325
       325
       +
       			// Verify the $type field is present and correct

     

       326
       326
       +
       			if typeVal, ok := ft.feature["$type"].(string); !ok || typeVal != ft.typeName {

     

       327
       327
       +
       				t.Errorf("Feature type mismatch: got %v, want %s", ft.feature["$type"], ft.typeName)

     

       328
       328
       +
       			}

     

       329
       329
       +
       

     

       330
       330
       +
       			// Create a complete facet with this feature

     

       331
       331
       +
       			facet := map[string]interface{}{

     

       332
       332
       +
       				"index": map[string]interface{}{

     

       333
       333
       +
       					"byteStart": 0,

     

       334
       334
       +
       					"byteEnd":   10,

     

       335
       335
       +
       				},

     

       336
       336
       +
       				"features": []interface{}{ft.feature},

     

       337
       337
       +
       			}

     

       338
       338
       +
       

     

       339
       339
       +
       			// Verify it can be marshaled/unmarshaled

     

       340
       340
       +
       			data, err := json.Marshal(facet)

     

       341
       341
       +
       			if err != nil {

     

       342
       342
       +
       				t.Errorf("Failed to marshal facet: %v", err)

     

       343
       343
       +
       			}

     

       344
       344
       +
       

     

       345
       345
       +
       			var decoded map[string]interface{}

     

       346
       346
       +
       			if err := json.Unmarshal(data, &decoded); err != nil {

     

       347
       347
       +
       				t.Errorf("Failed to unmarshal facet: %v", err)

     

       348
       348
       +
       			}

     

       349
       349
       +
       		})

     

       350
       350
       +
       	}

     

       351
       351
       +
       }

+2 -4

tests/lexicon_validation_test.go

···

       28
       28
        
       		"social.coves.post.image",

     

       29
       29
        
       		"social.coves.post.video",

     

       30
       30
        
       		"social.coves.post.article",

     

       31
       31
       -
       		"social.coves.richtext.markup",

     

       32
       32
       -
       		"social.coves.richtext.mention",

     

       33
       33
       -
       		"social.coves.richtext.link",

     

       31
       31
       +
       		"social.coves.richtext.facet",

     

       34
       32
        
       		"social.coves.embed.image",

     

       35
       33
        
       		"social.coves.embed.video",

     

       36
       34
        
       		"social.coves.embed.external",

     
···

       64
       62
        
       

     

       65
       63
        
       	// Test specific cross-references that should work

     

       66
       64
        
       	crossRefs := map[string]string{

     

       67
       67
       -
       		"social.coves.richtext.markup#byteSlice": "byteSlice definition in markup schema",

     

       65
       65
       +
       		"social.coves.richtext.facet#byteSlice": "byteSlice definition in facet schema",

     

       68
       66
        
       		"social.coves.actor.profile#geoLocation": "geoLocation definition in actor profile",

     

       69
       67
        
       		"social.coves.community.rules#rule":      "rule definition in community rules",

     

       70
       68
        
       	}

validate-lexicon

This is a binary file and will not be displayed.