init release

LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Wes Ring
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

README.md

@@ -1,3 +1,68 @@
----
-license: bsd-3-clause
----
+# SNIP Model Card
+
+## Model
+
+- Name: Small N-gram Identifier for Pastes (SNIP)
+- Package version: `1.0.0`
+- Model version: `snip-109`
+- Model file: `model/snip_model.json`
+- Runtime source: `src/snip.ts`
+- Published runtime: `dist/snip.js`
+
+## Intended Use
+
+SNIP predicts a likely syntax or text label for pasted text, snippets, logs, configuration files, and text-like source files. It is designed for browser-local inference in applications where sending pasted content to a server is undesirable. It aims to be quick, small in size, and fairly accurate.
+
+## Labels
+
+`bash`, `c`, `cpp`, `csharp`, `css`, `csv`, `diff`, `dockerfile`, `go`, `html`, `ini`, `java`, `javascript`, `json`, `log`, `lua`, `markdown`, `php`, `plain_text`, `powershell`, `python`, `ruby`, `rust`, `sql`, `toml`, `typescript`, `xml`, `yaml`.
+
+## Architecture
+
+- Multiclass linear classifier
+- Hashed character n-grams, length 1-5
+- 32,768 hash buckets
+- L2-normalized `log1p(count)` features
+- 1,500 retained weights per label
+- 4-decimal serialized weights
+- TypeScript source with no runtime dependencies
+
+## Size
+
+- Raw model JSON: 626,596 bytes
+- Gzip model JSON: 203,820 bytes
+
+## Performance
+
+Measured in Google Chrome 149.0.7827.116 on macOS:
+
+| Input size | Sampled chars | P50 ms | P95 ms |
+| --- | ---: | ---: | ---: |
+| 1 KB | 1,024 | 1.490 | 1.548 |
+| 16 KB | 16,384 | 6.580 | 6.730 |
+| 100 KB | 12,292 | 5.180 | 5.310 |
+| 1 MB | 12,292 | 5.170 | 5.310 |
+| 5 MB | 12,292 | 5.210 | 5.380 |
+
+## Metrics
+
+| Evaluation Set | Examples | Accuracy | Macro F1 |
+| --- | ---: | ---: | ---: |
+| Validation | 487 | 1.0000 | 1.0000 |
+| Test | 532 | 0.9962 | 0.9926 |
+| Hard cases | 148 | 0.9932 | 0.6905 |
+| Development holdouts | 207 | 0.9903 | - |
+| Regression holdouts | 196 | 0.9796 | - |
+| Final mixed holdout | 56 | 0.9821 | 0.9810 |
+
+## Limitations
+
+- Optimized for text, not binary file identification.
+- Very short snippets may lack enough evidence for a specific syntax label.
+- TypeScript and JavaScript can be close when a snippet has no type syntax.
+- JSONL application logs can be close to JSON.
+- Markdown/plain-text separation can be weak on very short prose-like Markdown.
+
+## Training Notes
+
+The training corpus combines generated structured text, curated programming examples, realistic local files, and targeted hard-neighbor examples.

REPORT.md

@@ -0,0 +1,246 @@
+# SNIP: Small N-gram Identifier for Pastes
+
+## Abstract
+
+SNIP is a compact text classifier designed for in-browser classification into a subset of labels common in pastebin websites. The release model predicts 28 source and text labels from a bounded sample using hashed character n-grams and a sparse linear classifier. It runs with a dependency-free JavaScript runtime.
+
+The release model reaches 1.0000 validation accuracy, 0.9962 test accuracy, 0.9816 held-out accuracy, and 0.9932 hard-case accuracy while staying around 205 KB gzip-compressed.
+
+## 1. Problem
+
+Pastebin sites, editors, and developer tools often need a useful syntax suggestion immediately after text is pasted. The goal of the classifier was to build something small enough to ship with a web app, and fast enough to feel instant. Binary file detection and full file-type forensics are outside the current scope.
+
+## 2. Labels
+
+The release label set is:
+
+`bash`, `c`, `cpp`, `csharp`, `css`, `csv`, `diff`, `dockerfile`, `go`, `html`, `ini`, `java`, `javascript`, `json`, `log`, `lua`, `markdown`, `php`, `plain_text`, `powershell`, `python`, `ruby`, `rust`, `sql`, `toml`, `typescript`, `xml`, `yaml`.
+
+## 3. Data
+
+The dataset was built iteratively. Early code samples were short and repetitive, which helped validate the pipeline but produced over-optimistic results. Those examples were replaced with more realistic files and fragments.
+
+Specifically for programming languages, the training set was generated by LLMs over successive training runs. Careful consideration was taken to avoid overfitting to a specific language or task. Examples were written as complete files or realistic project fragments: CLIs, web handlers, tests, services, configuration loaders, migrations, and framework code. This produced more useful character n-gram coverage than primitive string shuffling or pulling only from my personal code corpus, and allowed me to train a proficient model without personally maintaining a diverse codebase in every target language.
+
+Some label types are better suited to programmatic generation, such as JSON, CSV, and logs. Even there, the useful cases were varied by shape, length, field names, and value distributions rather than generated from one repeated template.
+
+The final training data emphasizes:
+
+1. realistic short snippets, because paste inputs are often not full files
+2. source-grouped splits, so related chunks do not leak across train/test
+3. explicit hard cases for ambiguous neighboring labels such as HTML/XML, INI/TOML, JSON/log, Markdown/plain text, and CSV/plain text
+
+### Distribution and quality checks
+
+| Split | Rows | Labels | Min chars | Median chars | P90 chars | Max chars |
+| --- | ---: | ---: | ---: | ---: | ---: | ---: |
+| Train | 2,618 | 28 | 20 | 210.5 | 1,124 | 33,617 |
+| Validation | 487 | 28 | 13 | 213 | 1,192 | 22,701 |
+| Test | 532 | 28 | 19 | 180 | 1,049 | 8,942 |
+
+<details>
+<summary>Training rows by label</summary>
+
+| Label | Train rows |
+| --- | ---: |
+| `bash` | 28 |
+| `c` | 28 |
+| `cpp` | 31 |
+| `csharp` | 32 |
+| `css` | 124 |
+| `csv` | 154 |
+| `diff` | 131 |
+| `dockerfile` | 114 |
+| `go` | 37 |
+| `html` | 132 |
+| `ini` | 148 |
+| `java` | 32 |
+| `javascript` | 38 |
+| `json` | 144 |
+| `log` | 163 |
+| `lua` | 29 |
+| `markdown` | 163 |
+| `php` | 33 |
+| `plain_text` | 314 |
+| `powershell` | 40 |
+| `python` | 43 |
+| `ruby` | 50 |
+| `rust` | 33 |
+| `sql` | 136 |
+| `toml` | 140 |
+| `typescript` | 37 |
+| `xml` | 127 |
+| `yaml` | 137 |
+
+</details>
+
+<details>
+<summary>Verification rows by label (validation, test, and held-out suites combined)</summary>
+
+| Label | Verification rows |
+| --- | ---: |
+| `bash` | 32 |
+| `c` | 32 |
+| `cpp` | 33 |
+| `csharp` | 33 |
+| `css` | 66 |
+| `csv` | 71 |
+| `diff` | 67 |
+| `dockerfile` | 66 |
+| `go` | 33 |
+| `html` | 68 |
+| `ini` | 67 |
+| `java` | 33 |
+| `javascript` | 34 |
+| `json` | 75 |
+| `log` | 72 |
+| `lua` | 32 |
+| `markdown` | 70 |
+| `php` | 32 |
+| `plain_text` | 257 |
+| `powershell` | 32 |
+| `python` | 37 |
+| `ruby` | 33 |
+| `rust` | 33 |
+| `sql` | 68 |
+| `toml` | 68 |
+| `typescript` | 33 |
+| `xml` | 68 |
+| `yaml` | 73 |
+
+</details>
+
+Rows by length bucket:
+
+| Split | <64 | 64-128 | 128-256 | 256-1K | 1K-4K | 4K-16K | 16K+ |
+| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
+| Train | 26 | 452 | 1,144 | 682 | 308 | 3 | 3 |
+| Validation | 5 | 89 | 202 | 128 | 62 | 0 | 1 |
+| Test | 13 | 125 | 213 | 124 | 55 | 2 | 0 |
+
+Training rows by source family:
+
+| Source family | Train rows | Purpose |
+| --- | ---: | --- |
+| Structured/generated format examples | 1,795 | Broad coverage for structured text, config, prose, and data formats |
+| Curated programming/project examples | 428 | Realistic source files and project fragments |
+| Targeted hard-neighbor additions | 310 | Short snippets and close label pairs found through error analysis |
+| Plain-text fallback examples | 63 | Text that should remain `plain_text` despite punctuation or weak structure |
+| Real local/project examples | 8 | Repository-derived real files |
+| Product/format-specific examples | 14 | Focused coverage for paste-product formats |
+
+Every candidate split was checked for exact and normalized duplicate text. Train-only additions after error analysis were also checked for exact and near-duplicate overlap against held-out suites before use.
+
+## 4. Model
+
+The release model is a multiclass linear classifier trained with a passive-aggressive update. Features are hashed character n-grams:
+
+- n-gram range: 1 through 5 characters
+- hash buckets: 32,768
+- feature value: `log1p(count)`
+- normalization: L2 normalization
+- shape features: disabled
+- retained weights: 1,500 per label
+- serialized weight precision: 4 decimal places
+
+Long inputs are sampled before classification. Inputs up to 16 KiB are classified whole. Longer inputs are represented by windows from the start, middle, and end, joined with a separator. This keeps browser inference bounded for large pastes while preserving signal from common file regions.
+
+## 5. Training
+
+The first strong model used a Naive Bayes classifier with character n-grams, but I ran into a wall trying to handle edge cases where sparse labels with cheap default probabilities could dominate real files.
+
+The linear model fixed that behavior. It scores labels directly from learned positive and negative weights instead of relying on per-class default probabilities. With top-weight pruning, the model stayed small enough for browser delivery while preserving the real-file behavior we wanted.
+
+### Training loop
+
+A major objective of training the n-gram was testing how much of training a model can be performed semi-autonomously by an LLM Agent. n-grams are incredibly fast to train, and afforded the model many opportunities to run experiences and build up a training dataset over time that specifically targeted failures in the trained models. A key part of getting that loop to work was ensuring the data stayed representative of a real-world text distribution while keeping the model from over-fitting to the generated dataset. The Agent was instructed to keep notes, an experiments log, and a data quality log. It did require a bit of nudging along the way, such as prompting it to manually inspect some of the generated data and note the quality issues (For example early C examples were almost all duplicates of 4-5 lines of a `main()` printing a few words). 
+
+Each round started with a candidate model trained on the current corpus. The agent evaluated it against the normal validation/test split, targeted hard cases for confused labels and the held-out evaluation suites. When the model failed, a subagent was used to describe the failures as broader missing shape: short prose-heavy Markdown, TOML that looks like INI, JSON-looking application logs, small diffs, short language snippets without imports, and so on.
+
+Those descriptions were then used to create new train-only examples. For programming languages, the examples were usually generated as realistic files or fragments rather than templates. For structured formats, the generation could be more programmatic, but still had to vary field names, lengths, nesting, and punctuation. Before a new training split was used, the added rows were checked against the rest of the corpus for exact or near-duplicate overlap.
+
+A separate LLM subagent was used to create new held-out evaluation suites between rounds. This was important to help ensure the overall quality of the train dataset. We want the generated examples to be different enough to keep the model robust. The held-out suites were generated from label-level requirements and broad scenario prompts, then locked before the next candidate was evaluated. Once a held-out suite exposed an error category and influenced the next data pass, it was no longer treated as a final benchmark. It became a regression suite.
+
+The loop looked like this:
+
+1. train a candidate on the current corpus
+2. evaluate against validation, test, hard cases, and held-out evaluation suites
+3. inspect failures as categories and patterns
+4. generate train-only coverage for those categories
+5. check duplicate and near-duplicate overlap
+6. train the next candidate
+7. create fresh held-out coverage when a release-quality claim is needed
+
+This process let the dataset grow in the directions the n-gram actually needed while keeping a clean separation between training data and held-out evaluation suites.
+
+| Evaluation role | Rows | Purpose |
+| --- | ---: | --- |
+| Validation + test | 1,019 | Main split evaluation |
+| Held-out suites | 599 | Independent checks generated across training rounds |
+| Hard-neighbor cases | 148 | Targeted stress cases for commonly confused labels |
+
+### Weight pruning
+
+After training, pruning is applied to help reduce the size of the model. Weights with an absolute value below `0.001` are removed, and each label keeps at most `1,500` learned n-gram weights, chosen by absolute value. The remaining weights are serialized to 4 decimal places. This was a simple way to cut model size while keeping the runtime and JSON model format straightforward.
+
+## 6. Results
+
+SNIP stats:
+
+| Evaluation set | Examples | Accuracy | Macro F1 | Known coverage |
+| --- | ---: | ---: | ---: | ---: |
+| Validation split | 487 | 1.0000 | 1.0000 | 1.0000 |
+| Test split | 532 | 0.9962 | 0.9926 | 1.0000 |
+| Held-out evaluation suites | 599 | 0.9816 | 0.9819 | 1.0000 |
+| Hard-neighbor cases | 148 | 0.9932 | 0.6905 | 1.0000 |
+
+Model size:
+
+| Artifact | Size |
+| --- | ---: |
+| `snip_model.json` | 626,595 bytes |
+| gzip-compressed model | 204,593 bytes |
+
+## 7. Performance
+
+SNIP's runtime target requires low latency because classification happens in user-facing paste flows and should not scale linearly with very large inputs. Performance was measured with the model embedded inside a single HTML file to remove any possible network latency.
+
+Captured result:
+
+- Browser: Google Chrome 149.0.7827.116
+- Platform: macOS arm64
+- Model parse: 4.4 ms
+
+| Input size | Sampled chars | Classifications | Mean ms | P50 ms | P95 ms |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| 1 KB | 1,024 | 5,000 | 1.499 | 1.490 | 1.548 |
+| 16 KB | 16,384 | 1,000 | 6.578 | 6.580 | 6.730 |
+| 100 KB | 12,292 | 800 | 5.195 | 5.180 | 5.310 |
+| 1 MB | 12,292 | 800 | 5.184 | 5.170 | 5.310 |
+| 5 MB | 12,292 | 800 | 5.238 | 5.210 | 5.380 |
+
+The non-monotonic timing is expected. Inputs up to 16 KiB are classified whole. Larger inputs are sampled into three 4 KiB windows plus separators, so 100 KB, 1 MB, and 5 MB inputs all classify roughly the same amount of text.
+
+## 8. Runtime
+
+The reference runtime is authored in `src/snip.ts`. It implements:
+
+1. bounded input sampling,
+2. FNV-1a style stable hashing over UTF-16 code units,
+3. character n-gram feature extraction,
+4. sparse linear scoring,
+5. softmax ranking.
+
+The runtime has no dependencies.
+
+## 9. Limitations
+
+SNIP is optimized for pasted text and text-like files. Binary file identification is outside the current release scope.
+
+The release model has known weaknesses:
+
+- very small structured snippets can still be close to `plain_text`
+- TypeScript and JavaScript can be close when the snippet lacks type syntax
+- SNIP scores every label and selects the highest-scoring label; the margin reports the gap to the runner-up
+- Markdown/plain-text separation is still weak on very short prose-like Markdown
+- INI/TOML and JSON/log remain close neighbors when examples are short.

metrics/summary.json

@@ -0,0 +1,91 @@
+{
+  "name": "SNIP",
+  "expanded_name": "Small N-gram Identifier for Pastes",
+  "metrics": {
+    "development_holdouts": {
+      "accuracy": 0.9903,
+      "examples": 207
+    },
+    "final_mixed_holdout": {
+      "accuracy": 0.9821428571428571,
+      "examples": 56,
+      "known_coverage": 1.0,
+      "macro_f1": 0.9809523809523809
+    },
+    "hard_cases": {
+      "accuracy": 0.9932432432432432,
+      "examples": 148,
+      "known_coverage": 1.0,
+      "macro_f1": 0.6904761904761905
+    },
+    "test": {
+      "accuracy": 0.9962406015037594,
+      "examples": 532,
+      "known_coverage": 1.0,
+      "macro_f1": 0.9926318594465098
+    },
+    "validation": {
+      "accuracy": 1.0,
+      "examples": 487,
+      "known_coverage": 1.0,
+      "macro_f1": 1.0
+    },
+    "regression_holdouts": {
+      "accuracy": 0.9796,
+      "examples": 196
+    }
+  },
+  "performance": {
+    "browser": "Google Chrome 149.0.7827.116",
+    "hardware": "Mac M2",
+    "model_parse_ms": 4.4,
+    "platform": "macOS arm64",
+    "results": [
+      {
+        "case": "1 KB paste",
+        "classifications": 5000,
+        "input_chars": 1024,
+        "mean_ms": 1.499,
+        "p50_ms": 1.49,
+        "p95_ms": 1.548,
+        "sampled_chars": 1024
+      },
+      {
+        "case": "16 KB paste",
+        "classifications": 1000,
+        "input_chars": 16384,
+        "mean_ms": 6.578,
+        "p50_ms": 6.58,
+        "p95_ms": 6.73,
+        "sampled_chars": 16384
+      },
+      {
+        "case": "100 KB paste",
+        "classifications": 800,
+        "input_chars": 102400,
+        "mean_ms": 5.195,
+        "p50_ms": 5.18,
+        "p95_ms": 5.31,
+        "sampled_chars": 12292
+      },
+      {
+        "case": "1 MB paste",
+        "classifications": 800,
+        "input_chars": 1048576,
+        "mean_ms": 5.184,
+        "p50_ms": 5.17,
+        "p95_ms": 5.31,
+        "sampled_chars": 12292
+      },
+      {
+        "case": "5 MB paste",
+        "classifications": 800,
+        "input_chars": 5242880,
+        "mean_ms": 5.238,
+        "p50_ms": 5.21,
+        "p95_ms": 5.38,
+        "sampled_chars": 12292
+      }
+    ]
+  }
+}

metrics/test_metrics.json

@@ -0,0 +1,202 @@
+{
+  "accuracy": 0.9962406015037594,
+  "known_abstain_rate": 0.0,
+  "known_coverage": 1.0,
+  "length_buckets": {
+    "000_lt_256": {
+      "accuracy": 0.9971509971509972,
+      "total": 351,
+      "unknown_rate": 0.0
+    },
+    "001_256_1k": {
+      "accuracy": 0.9919354838709677,
+      "total": 124,
+      "unknown_rate": 0.0
+    },
+    "002_1k_4k": {
+      "accuracy": 1.0,
+      "total": 55,
+      "unknown_rate": 0.0
+    },
+    "003_4k_16k": {
+      "accuracy": 1.0,
+      "total": 2,
+      "unknown_rate": 0.0
+    }
+  },
+  "macro_f1": 0.9926318594465098,
+  "per_label": {
+    "bash": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 6
+    },
+    "c": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 6
+    },
+    "cpp": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 6
+    },
+    "csharp": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 6
+    },
+    "css": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 23
+    },
+    "csv": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 26
+    },
+    "diff": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 23
+    },
+    "dockerfile": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 23
+    },
+    "go": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 6
+    },
+    "html": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 24
+    },
+    "ini": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 24
+    },
+    "java": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 6
+    },
+    "javascript": {
+      "f1": 0.923076923076923,
+      "precision": 0.8571428571428571,
+      "recall": 1.0,
+      "support": 6
+    },
+    "json": {
+      "f1": 0.9803921568627451,
+      "precision": 1.0,
+      "recall": 0.9615384615384616,
+      "support": 26
+    },
+    "log": {
+      "f1": 0.9811320754716981,
+      "precision": 0.9629629629629629,
+      "recall": 1.0,
+      "support": 26
+    },
+    "lua": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 6
+    },
+    "markdown": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 23
+    },
+    "php": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 6
+    },
+    "plain_text": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 132
+    },
+    "powershell": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 6
+    },
+    "python": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 7
+    },
+    "ruby": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 6
+    },
+    "rust": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 6
+    },
+    "sql": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 24
+    },
+    "toml": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 23
+    },
+    "typescript": {
+      "f1": 0.9090909090909091,
+      "precision": 1.0,
+      "recall": 0.8333333333333334,
+      "support": 6
+    },
+    "xml": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 24
+    },
+    "yaml": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 26
+    }
+  },
+  "total": 532,
+  "unknown_false_accept_rate": 0.0,
+  "unknown_rate": 0.0,
+  "unknown_rejection_rate": 0.0
+}

metrics/val_metrics.json

@@ -0,0 +1,202 @@
+{
+  "accuracy": 1.0,
+  "known_abstain_rate": 0.0,
+  "known_coverage": 1.0,
+  "length_buckets": {
+    "000_lt_256": {
+      "accuracy": 1.0,
+      "total": 296,
+      "unknown_rate": 0.0
+    },
+    "001_256_1k": {
+      "accuracy": 1.0,
+      "total": 128,
+      "unknown_rate": 0.0
+    },
+    "002_1k_4k": {
+      "accuracy": 1.0,
+      "total": 62,
+      "unknown_rate": 0.0
+    },
+    "004_16k_plus": {
+      "accuracy": 1.0,
+      "total": 1,
+      "unknown_rate": 0.0
+    }
+  },
+  "macro_f1": 1.0,
+  "per_label": {
+    "bash": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 6
+    },
+    "c": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 6
+    },
+    "cpp": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 6
+    },
+    "csharp": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 6
+    },
+    "css": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 23
+    },
+    "csv": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 25
+    },
+    "diff": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 24
+    },
+    "dockerfile": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 22
+    },
+    "go": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 6
+    },
+    "html": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 23
+    },
+    "ini": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 23
+    },
+    "java": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 6
+    },
+    "javascript": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 6
+    },
+    "json": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 26
+    },
+    "log": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 25
+    },
+    "lua": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 6
+    },
+    "markdown": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 24
+    },
+    "php": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 6
+    },
+    "plain_text": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 92
+    },
+    "powershell": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 6
+    },
+    "python": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 7
+    },
+    "ruby": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 6
+    },
+    "rust": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 6
+    },
+    "sql": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 23
+    },
+    "toml": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 24
+    },
+    "typescript": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 6
+    },
+    "xml": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 23
+    },
+    "yaml": {
+      "f1": 1.0,
+      "precision": 1.0,
+      "recall": 1.0,
+      "support": 25
+    }
+  },
+  "total": 487,
+  "unknown_false_accept_rate": 0.0,
+  "unknown_rate": 0.0,
+  "unknown_rejection_rate": 0.0
+}

runtime/snip.js

@@ -0,0 +1,146 @@
+import model from "./model-data.js";
+export const SNIP_LABELS = [
+    "bash",
+    "c",
+    "cpp",
+    "csharp",
+    "css",
+    "csv",
+    "diff",
+    "dockerfile",
+    "go",
+    "html",
+    "ini",
+    "java",
+    "javascript",
+    "json",
+    "log",
+    "lua",
+    "markdown",
+    "php",
+    "plain_text",
+    "powershell",
+    "python",
+    "ruby",
+    "rust",
+    "sql",
+    "toml",
+    "typescript",
+    "xml",
+    "yaml",
+];
+export function classifyText(text) {
+    return classifyWithModel(text, model);
+}
+export async function classifyTextAsync(text) {
+    await yieldToBrowser();
+    return classifyText(text);
+}
+function classifyWithModel(text, model) {
+    if (model.config.model_type !== "linear_pa") {
+        throw new Error(`unsupported SNIP model type: ${model.config.model_type}`);
+    }
+    const sampled = sampleWithConfig(text, model.config.sampling);
+    const features = extractFeatures(sampled, model.config.feature);
+    const scores = new Map();
+    for (const label of model.config.labels) {
+        let score = model.bias?.[label] ?? 0;
+        const weights = model.weights[label] ?? [];
+        for (const [key, weight] of weights) {
+            score += (features.get(key) ?? 0) * weight;
+        }
+        scores.set(label, score);
+    }
+    const probabilities = softmax(scores);
+    const alternatives = [...probabilities.entries()].sort((a, b) => b[1] - a[1]);
+    const [predictedLabel, confidence] = alternatives[0] ?? [model.config.fallback_label ?? "plain_text", 0];
+    const second = alternatives[1]?.[1] ?? 0;
+    const margin = confidence - second;
+    const threshold = model.config.thresholds?.[predictedLabel] ?? 0;
+    const marginThreshold = model.config.margin_thresholds?.[predictedLabel] ?? 0;
+    const fallback = model.config.fallback_label ?? "plain_text";
+    const accepted = confidence >= threshold && margin >= marginThreshold;
+    return {
+        label: accepted ? predictedLabel : fallback,
+        predicted_label: predictedLabel,
+        confidence,
+        margin,
+        alternatives: alternatives.slice(0, 5),
+    };
+}
+export function sampleText(text) {
+    return sampleWithConfig(text, model.config.sampling);
+}
+function sampleWithConfig(text, config) {
+    if (text.length <= config.small_cutoff)
+        return text;
+    const windowSize = config.window_size;
+    const start = text.slice(0, windowSize);
+    const midpoint = Math.floor(text.length / 2);
+    const half = Math.floor(windowSize / 2);
+    const middle = text.slice(Math.max(0, midpoint - half), Math.min(text.length, midpoint + half));
+    const end = text.slice(-windowSize);
+    return [start, middle, end].join(config.separator);
+}
+function extractFeatures(text, config) {
+    if (config.lowercase)
+        text = text.toLowerCase();
+    const counts = new Map();
+    const padded = ` ${text} `;
+    for (let n = config.ngram_min; n <= config.ngram_max; n += 1) {
+        if (padded.length < n)
+            continue;
+        for (let i = 0; i <= padded.length - n; i += 1) {
+            const key = stableHash(`char${n}:${padded.slice(i, i + n)}`, config.hash_buckets);
+            counts.set(key, (counts.get(key) ?? 0) + 1);
+        }
+    }
+    const features = new Map();
+    let norm = 0;
+    for (const [key, value] of counts.entries()) {
+        const transformed = config.binary_counts ? 1 : Math.log1p(value);
+        features.set(key, transformed);
+        norm += transformed * transformed;
+    }
+    if (config.normalize && norm > 0) {
+        const scale = Math.sqrt(norm);
+        for (const [key, value] of features.entries()) {
+            features.set(key, value / scale);
+        }
+    }
+    return features;
+}
+function stableHash(text, buckets) {
+    let value = 2166136261 >>> 0;
+    for (let i = 0; i < text.length; i += 1) {
+        const code = text.charCodeAt(i);
+        value ^= code & 0xff;
+        value = Math.imul(value, 16777619) >>> 0;
+        value ^= (code >>> 8) & 0xff;
+        value = Math.imul(value, 16777619) >>> 0;
+    }
+    return value % buckets;
+}
+function yieldToBrowser() {
+    return new Promise((resolve) => {
+        if (typeof globalThis.requestAnimationFrame === "function") {
+            globalThis.requestAnimationFrame(() => resolve());
+            return;
+        }
+        globalThis.setTimeout(resolve, 0);
+    });
+}
+function softmax(scores) {
+    const maxScore = Math.max(...scores.values());
+    const probabilities = new Map();
+    let total = 0;
+    for (const [label, score] of scores.entries()) {
+        const value = Math.exp(score - maxScore);
+        probabilities.set(label, value);
+        total += value;
+    }
+    for (const [label, value] of probabilities.entries()) {
+        probabilities.set(label, value / total);
+    }
+    return probabilities;
+}

runtime/snip.ts

@@ -0,0 +1,211 @@
+import model from "./model-data.js";
+
+export const SNIP_LABELS = [
+  "bash",
+  "c",
+  "cpp",
+  "csharp",
+  "css",
+  "csv",
+  "diff",
+  "dockerfile",
+  "go",
+  "html",
+  "ini",
+  "java",
+  "javascript",
+  "json",
+  "log",
+  "lua",
+  "markdown",
+  "php",
+  "plain_text",
+  "powershell",
+  "python",
+  "ruby",
+  "rust",
+  "sql",
+  "toml",
+  "typescript",
+  "xml",
+  "yaml",
+] as const;
+
+export type SnipLabel = (typeof SNIP_LABELS)[number];
+
+export interface SnipFeatureConfig {
+  ngram_min: number;
+  ngram_max: number;
+  hash_buckets: number;
+  lowercase: boolean;
+  binary_counts: boolean;
+  normalize: boolean;
+  add_shape_features?: boolean;
+}
+
+export interface SnipSamplingConfig {
+  small_cutoff: number;
+  window_size: number;
+  separator: string;
+}
+
+export interface SnipModelConfig {
+  model_type: "linear_pa";
+  name?: string;
+  labels: SnipLabel[];
+  feature: SnipFeatureConfig;
+  sampling: SnipSamplingConfig;
+  fallback_label?: SnipLabel;
+  thresholds?: Partial<Record<SnipLabel, number>>;
+  margin_thresholds?: Partial<Record<SnipLabel, number>>;
+  [key: string]: unknown;
+}
+
+export interface SnipModel {
+  config: SnipModelConfig;
+  bias?: Partial<Record<SnipLabel, number>>;
+  weights: Partial<Record<SnipLabel, Array<[number, number]>>>;
+}
+
+export interface ClassificationResult {
+  label: SnipLabel;
+  predicted_label: SnipLabel;
+  confidence: number;
+  margin: number;
+  alternatives: Array<[SnipLabel, number]>;
+}
+
+export function classifyText(text: string): ClassificationResult {
+  return classifyWithModel(text, model);
+}
+
+export async function classifyTextAsync(text: string): Promise<ClassificationResult> {
+  await yieldToBrowser();
+  return classifyText(text);
+}
+
+function classifyWithModel(text: string, model: SnipModel): ClassificationResult {
+  if (model.config.model_type !== "linear_pa") {
+    throw new Error(`unsupported SNIP model type: ${model.config.model_type}`);
+  }
+
+  const sampled = sampleWithConfig(text, model.config.sampling);
+  const features = extractFeatures(sampled, model.config.feature);
+  const scores = new Map<SnipLabel, number>();
+
+  for (const label of model.config.labels) {
+    let score = model.bias?.[label] ?? 0;
+    const weights = model.weights[label] ?? [];
+    for (const [key, weight] of weights) {
+      score += (features.get(key) ?? 0) * weight;
+    }
+    scores.set(label, score);
+  }
+
+  const probabilities = softmax(scores);
+  const alternatives = [...probabilities.entries()].sort((a, b) => b[1] - a[1]);
+  const [predictedLabel, confidence] = alternatives[0] ?? [model.config.fallback_label ?? "plain_text", 0];
+  const second = alternatives[1]?.[1] ?? 0;
+  const margin = confidence - second;
+  const threshold = model.config.thresholds?.[predictedLabel] ?? 0;
+  const marginThreshold = model.config.margin_thresholds?.[predictedLabel] ?? 0;
+  const fallback = model.config.fallback_label ?? "plain_text";
+  const accepted = confidence >= threshold && margin >= marginThreshold;
+
+  return {
+    label: accepted ? predictedLabel : fallback,
+    predicted_label: predictedLabel,
+    confidence,
+    margin,
+    alternatives: alternatives.slice(0, 5),
+  };
+}
+
+export function sampleText(text: string): string {
+  return sampleWithConfig(text, model.config.sampling);
+}
+
+function sampleWithConfig(text: string, config: SnipSamplingConfig): string {
+  if (text.length <= config.small_cutoff) return text;
+
+  const windowSize = config.window_size;
+  const start = text.slice(0, windowSize);
+  const midpoint = Math.floor(text.length / 2);
+  const half = Math.floor(windowSize / 2);
+  const middle = text.slice(
+    Math.max(0, midpoint - half),
+    Math.min(text.length, midpoint + half),
+  );
+  const end = text.slice(-windowSize);
+  return [start, middle, end].join(config.separator);
+}
+
+function extractFeatures(text: string, config: SnipFeatureConfig): Map<number, number> {
+  if (config.lowercase) text = text.toLowerCase();
+
+  const counts = new Map<number, number>();
+  const padded = ` ${text} `;
+  for (let n = config.ngram_min; n <= config.ngram_max; n += 1) {
+    if (padded.length < n) continue;
+    for (let i = 0; i <= padded.length - n; i += 1) {
+      const key = stableHash(`char${n}:${padded.slice(i, i + n)}`, config.hash_buckets);
+      counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+  }
+
+  const features = new Map<number, number>();
+  let norm = 0;
+  for (const [key, value] of counts.entries()) {
+    const transformed = config.binary_counts ? 1 : Math.log1p(value);
+    features.set(key, transformed);
+    norm += transformed * transformed;
+  }
+
+  if (config.normalize && norm > 0) {
+    const scale = Math.sqrt(norm);
+    for (const [key, value] of features.entries()) {
+      features.set(key, value / scale);
+    }
+  }
+
+  return features;
+}
+
+function stableHash(text: string, buckets: number): number {
+  let value = 2166136261 >>> 0;
+  for (let i = 0; i < text.length; i += 1) {
+    const code = text.charCodeAt(i);
+    value ^= code & 0xff;
+    value = Math.imul(value, 16777619) >>> 0;
+    value ^= (code >>> 8) & 0xff;
+    value = Math.imul(value, 16777619) >>> 0;
+  }
+  return value % buckets;
+}
+
+function yieldToBrowser(): Promise<void> {
+  return new Promise((resolve) => {
+    if (typeof globalThis.requestAnimationFrame === "function") {
+      globalThis.requestAnimationFrame(() => resolve());
+      return;
+    }
+    globalThis.setTimeout(resolve, 0);
+  });
+}
+
+function softmax(scores: Map<SnipLabel, number>): Map<SnipLabel, number> {
+  const maxScore = Math.max(...scores.values());
+  const probabilities = new Map<SnipLabel, number>();
+  let total = 0;
+
+  for (const [label, score] of scores.entries()) {
+    const value = Math.exp(score - maxScore);
+    probabilities.set(label, value);
+    total += value;
+  }
+
+  for (const [label, value] of probabilities.entries()) {
+    probabilities.set(label, value / total);
+  }
+  return probabilities;
+}