@jaypie/mcp 0.8.47 → 0.8.48

package/dist/suites/docs/index.js

@@ -9,7 +9,7 @@ import { gt } from 'semver';
 /**
  * Docs Suite - Documentation services (skill, version, release_notes)
  */
-const BUILD_VERSION_STRING = "@jaypie/mcp@0.8.47#d4678bbc"
+const BUILD_VERSION_STRING = "@jaypie/mcp@0.8.48#ce72b43d"
     ;
 const __filename$1 = fileURLToPath(import.meta.url);
 const __dirname$1 = path.dirname(__filename$1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jaypie/mcp",
-  "version": "0.8.47",
+  "version": "0.8.48",
   "description": "Jaypie MCP",
   "repository": {
     "type": "git",

package/release-notes/fabricator/0.3.2.md

@@ -0,0 +1,28 @@
+---
+version: 0.3.2
+date: 2026-04-24
+summary: Adds fab.corpus() for seeded corpus text generation
+---
+
+## Changes
+
+- New `fab.corpus(words?, options?)` method on `Fabricator` for generating deterministic prose fixtures.
+- Default 108 words; pass a number for any other size.
+- Custom corpus support: pass `corpus` (raw text) or `words` (explicit weights). Custom and default English pools blend 50/50 by default; tune with `blend` or skip defaults with `replaceDefaults: true`.
+- Custom token functions via `functions` option — each function receives the fabricator and emits one token per draw, with weight subtracted from the main word stream. Useful for UUIDs, dollar amounts, emails, and other non-word-shaped tokens. Shorthand `[fn, weight]` for one function, `[[fn1, w1], [fn2, w2]]` for many.
+- Full passthrough of typo rate, phonotactic rate, sentence/punctuation density, and a `chars` escape hatch for char-length output.
+- `CorpusOptions`, `CorpusTokenFunction`, and `CorpusFunctionEntry` types exported from `@jaypie/fabricator`.
+
+## Determinism contract
+
+- Each call advances the fabricator's faker state, so successive calls with the same params return different output (`fab.corpus(100) !== fab.corpus(100)`).
+- Replaying from a fresh `fabricator(seed)` reproduces the same sequence.
+- Word count and options are folded into the per-call seed, so different params produce independent streams — `corpus(100)` and `corpus(101)` are not off-by-one variants of each other.
+
+## Why
+
+Test fixtures and seeded benchmarks frequently want bulk prose with stable, reproducible content. `lorem` is too uniform; ad-hoc generators are non-deterministic. `corpus()` fills that gap with a single ergonomic call that respects the fabricator's seeding contract.
+
+## Implementation note
+
+Generator internals (`babble`, `phonotactic`, English word/typo data, `Rng`) live in `src/corpus/` as a private vendored module. They are not exported — only the `corpus()` method and `CorpusOptions` type.

package/release-notes/mcp/0.8.48.md

@@ -0,0 +1,10 @@
+---
+version: 0.8.48
+date: 2026-04-24
+summary: Update fabricator skill with corpus() coverage
+---
+
+## Changes
+
+- Added a Corpus section to `skill("fabricator")` covering `fab.corpus()`: signatures, determinism contract (advance per call, replay across runs, params-folded-into-seed), custom corpus blending (`corpus`, `words`, `blend`, `replaceDefaults`), and custom token functions (`functions` shorthand and array forms).
+- Documented the full `CorpusOptions` shape and `CorpusTokenFunction` type.

package/skills/fabricator.md

@@ -85,6 +85,82 @@ fab.generate.person();
 - **RARE (2.1%)**: firstName is a surname, lastName is hyphenated
 - **EPIC (0.307%)**: double middle names
 
+### Corpus
+
+Generate deterministic prose for fixtures, snapshots, or seeded benchmarks.
+
+```typescript
+const fab = fabricator("seed");
+
+fab.corpus();              // 108 words of English-ish prose (default)
+fab.corpus(1000);          // 1000 words
+fab.corpus({ wordsPerPeriod: 10 });
+fab.corpus(500, { typoRate: 0.20 });
+```
+
+#### Determinism contract
+
+- Each call **advances** the fabricator's faker state, so successive calls with the same params return different output (`fab.corpus(100) !== fab.corpus(100)`).
+- Replaying from a fresh `fabricator(seed)` reproduces the same sequence.
+- Word count and options are folded into the per-call seed, so different params produce **independent** streams. `corpus(100)` and `corpus(101)` differ across the whole text — not by one word.
+
+#### Custom corpus
+
+Mix domain vocabulary into the output. By default the custom pool blends 50/50 with default English; typo (~6%) and phonotactic invention (~3%) rates stay at their defaults.
+
+```typescript
+fab.corpus(500, { corpus: deployLogText });            // raw text → derived weights
+fab.corpus(500, { words: [["deploy", 5], ["lambda", 2]] });
+
+fab.corpus(500, { corpus: deployLogText, blend: 0.7 }); // tune the mix
+fab.corpus(500, { corpus: deployLogText, replaceDefaults: true }); // pure custom
+```
+
+#### Custom token functions
+
+For non-word-shaped tokens (UUIDs, dollar amounts, IDs), pass `functions`. Each function receives the fabricator and emits one token per draw. Weight is the share of total content tokens taken from the main word stream.
+
+```typescript
+// Shorthand for a single function
+fab.corpus(500, {
+  functions: [({ fab }) => fab.string.uuid(), 0.03],
+});
+
+// Multiple functions
+fab.corpus(500, {
+  functions: [
+    [({ fab }) => fab.string.uuid(), 0.03],
+    [({ fab }) => "$" + fab.finance.amount(), 0.04],
+    [({ fab }) => fab.internet.email(), 0.02],
+  ],
+});
+```
+
+#### Full options
+
+```typescript
+interface CorpusOptions {
+  corpus?: string;                                  // raw text → derive weights
+  words?: ReadonlyArray<readonly [string, number]>; // explicit weights
+  blend?: number;                                   // share given to custom pool, default 0.5
+  replaceDefaults?: boolean;                        // skip default English entirely
+  typos?: ReadonlyArray<readonly [string, number]>; // override typo pool
+  phonotactic?: PhonotacticOptions;                 // tune invented words
+  typoRate?: number;                                // default 0.06
+  phonotacticRate?: number;                         // default 0.03
+  wordsPerPeriod?: number;                          // default 17
+  wordsPerComma?: number;                           // default 22
+  periodsPerBreak?: number;                         // default 5
+  sentences?: boolean;                              // default true
+  chars?: number;                                   // generate by char length instead of word count
+  functions?:                                       // custom token functions
+    | readonly [CorpusTokenFunction, number]
+    | ReadonlyArray<readonly [CorpusTokenFunction, number]>;
+}
+
+type CorpusTokenFunction = (params: { fab: Fabricator }) => string;
+```
+
 ## CHANCE Constants
 
 ```typescript