pict-section-prompteditor 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Steven Velozo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,118 @@
+# pict-section-prompteditor
+
+> **[Read the Pict-Section-PromptEditor Documentation](https://fable-retold.github.io/pict-section-prompteditor/)** - interactive docs with the full API reference and a runnable example.
+
+A prompt crafting and management section for the [Pict](https://github.com/fable-retold/pict) ecosystem. Prompts are markdown organized by type into segments, word list matrices with weights drive a `{~WordListEntry:Name~}` template expression, and one crafted prompt generates endless concrete variants you can browse and download as a zip.
+
+[MIT License](LICENSE)
+
+## Features
+
+- Typed prompts with markdown segments (Context / Request / Success Criteria and friends), plus **fixed preamble** segments for locked team standards
+- Weighted word list matrices: `[["Tyrannosaurus", 3], ["Diplodocus", 1]]` draws 75/25, with live share percentages as you curate
+- The `{~WordListEntry:Name~}` template expression (short form `{~WLE:~}`), with an optional miss default: `{~WLE:Name:fallback~}`
+- Generation runs the **real pict template engine**, so every pict expression works inside a prompt
+- Inline preview with reroll, Formatted / Markdown toggle, and a copy button
+- Batch generation with provenance, browsed in file order, downloaded as a zip of `<slug>-<sequence>.md` files
+- Pluggable data backplane: in-memory by default, one `PromptDataProvider` class to back it with your API
+- Opaque `Meta`, `Author` stamping, stable keys, and mutation hooks: the seams a host platform layers ratings and collaboration onto
+- Resizable, collapsible list rail (a pict-section-modal panel) and a searchable insert control (pict-section-picker)
+- Rich segment editing via pict-section-markdowneditor in a modal when CodeMirror is available; plain textareas otherwise
+
+## Installation
+
+```bash
+npm install pict-section-prompteditor
+```
+
+## Quick Start
+
+```javascript
+const libPromptEditor = require('pict-section-prompteditor');
+
+pict.addView('PromptEditor', Object.assign({}, libPromptEditor.default_configuration,
+{
+	DefaultDestinationAddress: '#My-Container',
+	Title: 'Team Prompt Workshop',
+	CurrentUser: { Key: 42, Name: 'Steven' }
+}), libPromptEditor);
+
+let tmpEditor = pict.views['PromptEditor'];
+tmpEditor.render();
+
+// Seed through the provider (in-memory by default), then reload the section.
+tmpEditor._provider.createWordList(
+	{ Name: 'Dinosaurs', Entries: [['Tyrannosaurus', 3], ['Diplodocus', 1]] })
+	.then(() => tmpEditor.load());
+```
+
+The section renders three tabs: Prompts (the editor), Word Lists (the matrices), and Generated (the browseable output with a zip download). Write `{~WordListEntry:Dinosaurs~}` in any segment and each generation draws Tyrannosaurus 75% of the time.
+
+To back it with your own API instead of memory, implement the twelve-method `PromptDataProvider` contract and pass it as `DataProvider` -- the in-memory provider is the reference implementation.
+
+## Documentation
+
+Full documentation is available in the [docs/](./docs/) directory and hosted at [fable-retold.github.io/pict-section-prompteditor](https://fable-retold.github.io/pict-section-prompteditor/):
+
+- [Quickstart](./docs/getting-started.md) -- install, mount, seed, generate
+- [Configuration](./docs/configuration.md) -- complete options reference
+- [Architecture](./docs/architecture.md) -- the design, with a diagram
+- [API Reference](./docs/api.md) -- classes, methods, and contracts
+- [Developer Functions](./docs/functions.md) -- a snippet for every exposed function
+- [Examples](./docs/examples.md) -- the Prompt Workshop example application
+
+## Example Applications
+
+| Example | Description |
+|---------|-------------|
+| [Prompt Workshop](./example_applications/prompt_workshop/) | The full section in memory: seeded word lists and prompts, inline preview with reroll, batch generation, zip download |
+
+Build it:
+
+```bash
+cd example_applications/prompt_workshop
+npm install
+npx quack build && npx quack copy
+# serve dist/ and open index.html — or `npm run example` from the module root
+```
+
+## API Overview
+
+| Export | Description |
+|--------|-------------|
+| *(default)* / `default_configuration` | The section view class and its full default options |
+| `PromptDataProvider` | The data contract a host implements |
+| `InMemoryPromptProvider` | The default provider; deterministic via `Now` / `KeyGenerator` options |
+| `DefaultPromptTypes` / `resolvePromptTypes` / `getPromptType` | The built-in prompt types and their resolution helpers |
+| `PromptCompiler` | `assembleSource`, `generate`, `wordListMap`, `slug`, `generatedFileName` |
+| `PromptZip` | `buildZip`, `downloadBlob` |
+| `PictTemplateWordListEntry` / `weightedPick` | The template expression class and the weighted draw |
+| `normalizeEntries` | Word list entry normalization |
+
+View instance methods hosts call: `load()`, `refresh()`, `setReadOnly(bool)`, `setDataProvider(provider)` -- plus every UI action as a drivable method. See [Developer Functions](./docs/functions.md) for snippets.
+
+## Testing
+
+```bash
+npm test
+```
+
+Fifty-seven mocha tests cover the provider contract, the weighted draw and expression, the compiler, zip round-trips, and the view (including focus-preserving edits and multi-instance isolation).
+
+## Related Packages
+
+- [pict](https://github.com/fable-retold/pict) -- Core MVC framework
+- [pict-view](https://github.com/fable-retold/pict-view) -- Base view class
+- [pict-section-modal](https://github.com/fable-retold/pict-section-modal) -- Dialogs, toasts, and the resizable rail panel
+- [pict-section-picker](https://github.com/fable-retold/pict-section-picker) -- The searchable insert control
+- [pict-section-markdowneditor](https://github.com/fable-retold/pict-section-markdowneditor) -- The rich segment editor
+- [pict-section-content](https://github.com/fable-retold/pict-section-content) -- Markdown rendering
+- [fable](https://github.com/fable-retold/fable) -- Service provider and dependency injection
+
+## License
+
+MIT
+
+## Contributing
+
+Pull requests are welcome. For major changes, please open an issue first.

package/package.json

@@ -0,0 +1,45 @@
+{
+	"name": "pict-section-prompteditor",
+	"version": "1.0.0",
+	"description": "Prompt crafting and management section for Pict: typed prompts with segments (context, request, success criteria), curated word list matrices with weights, a {~WordListEntry:Name~} template expression for weighted-random generation, batch generation with zip download, and a pluggable data provider that defaults to in-memory AppData.",
+	"main": "source/Pict-Section-PromptEditor.js",
+	"files": [
+		"source"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/fable-retold/pict-section-prompteditor.git"
+	},
+	"scripts": {
+		"test": "npx mocha -u tdd -R spec --exit test/*_tests.js",
+		"start": "node source/Pict-Section-PromptEditor.js",
+		"build": "npx quack build",
+		"build:codemirror": "node build/build-codemirror-bundle.js",
+		"example": "npx quack examples",
+		"docs": "npx quack prepare-docs ./docs"
+	},
+	"author": "steven velozo <steven@velozo.com>",
+	"license": "MIT",
+	"dependencies": {
+		"jszip": "^3.10.1",
+		"pict-section-content": "^1.0.15",
+		"pict-section-markdowneditor": "^1.0.17",
+		"pict-section-modal": "^1.1.4",
+		"pict-section-picker": "^1.4.0",
+		"pict-template": "^1.0.15",
+		"pict-view": "^1.0.68"
+	},
+	"devDependencies": {
+		"@codemirror/lang-markdown": "^6.5.0",
+		"@codemirror/state": "^6.6.0",
+		"@codemirror/view": "^6.43.0",
+		"chai": "^4.5.0",
+		"codemirror": "^6.0.2",
+		"esbuild": "^0.28.0",
+		"jsdom": "^25.0.1",
+		"mocha": "^11.0.1",
+		"pict": "^1.0.381",
+		"pict-docuserve": "^1.4.19",
+		"quackage": "^1.3.0"
+	}
+}

package/source/Pict-Section-PromptEditor.js

@@ -0,0 +1,56 @@
+'use strict';
+
+/**
+ * pict-section-prompteditor
+ *
+ * A self-contained Pict section for crafting, curating, and generating AI
+ * prompts as a team:
+ *
+ *   - prompts are markdown, organized by prompt type into segments
+ *     (context / request / success criteria and friends), with fixed-preamble
+ *     segments for locked team standards
+ *   - word list matrices ([["Tyrannosaurus", 3], ["Diplodocus", 1]]) drive the
+ *     {~WordListEntry:Dinosaurs~} template expression by weighted random
+ *   - any pict template expression works inside a prompt; generation runs the
+ *     assembled markdown through the real pict template engine
+ *   - generate as many concrete prompts as you like, browse them rendered,
+ *     download them as a zip of markdown files
+ *   - state is in-memory by default; implement PromptDataProvider to map the
+ *     section onto your own back end
+ *
+ * The default export is the view class, registered like any pict view:
+ *
+ *   const libPromptEditor = require('pict-section-prompteditor');
+ *   pict.addView('PromptEditor', Object.assign({}, libPromptEditor.default_configuration,
+ *     { DefaultDestinationAddress: '#My-Container' }), libPromptEditor);
+ *   pict.views['PromptEditor'].render();
+ */
+
+const libPromptEditorView = require('./views/PictView-PromptEditor.js');
+const libProvider = require('./providers/PromptProvider-Base.js');
+const libTypes = require('./types/PromptEditor-DefaultTypes.js');
+const libCompiler = require('./compiler/PromptCompiler.js');
+const libZip = require('./zip/PromptZip.js');
+const libWordListTemplate = require('./templates/Pict-Template-WordListEntry.js');
+
+module.exports = libPromptEditorView;
+module.exports.default_configuration = libPromptEditorView.default_configuration;
+
+// The data seam: the interface a host implements + the in-memory default.
+module.exports.PromptDataProvider = libProvider.PromptDataProvider;
+module.exports.InMemoryPromptProvider = libProvider.InMemoryPromptProvider;
+module.exports.normalizeEntries = libProvider.normalizeEntries;
+
+// Prompt types: the built-ins and the helpers the view uses to resolve them.
+module.exports.DefaultPromptTypes = libTypes.DefaultPromptTypes;
+module.exports.resolvePromptTypes = libTypes.resolvePromptTypes;
+module.exports.getPromptType = libTypes.getPromptType;
+
+// The compiler and zip utilities, for hosts generating outside the view.
+module.exports.PromptCompiler = libCompiler;
+module.exports.PromptZip = libZip;
+
+// The template expression class (registered automatically by the view; exposed
+// for hosts that want {~WordListEntry:~} active before any section mounts).
+module.exports.PictTemplateWordListEntry = libWordListTemplate;
+module.exports.weightedPick = libWordListTemplate.weightedPick;

package/source/compiler/PromptCompiler.js

@@ -0,0 +1,120 @@
+'use strict';
+
+/**
+ * PromptCompiler: a prompt record + its type --> markdown.
+ *
+ * Two stages, deliberately separate:
+ *
+ *   assembleSource() stitches the segments into one markdown document, fixed
+ *   preambles included, template expressions left intact. This is the SOURCE
+ *   of a prompt -- what you version, diff, and collaborate on.
+ *
+ *   generate() runs that source through the pict template engine with the
+ *   word lists in the parse data, so {~WordListEntry:Name~} resolves by
+ *   weighted random and every other pict expression works too (the prompt
+ *   record itself is addressable: {~D:Prompt.Title~}). Each call is one
+ *   concrete generation; call it as many times as you like.
+ */
+
+/**
+ * Filesystem-friendly slug for zip entry names.
+ * @param {string} pText
+ * @returns {string}
+ */
+function slug(pText)
+{
+	return String(pText || '').toLowerCase()
+		.replace(/[^a-z0-9]+/g, '-')
+		.replace(/^-+|-+$/g, '')
+		.slice(0, 60) || 'prompt';
+}
+
+/**
+ * Assemble a prompt's markdown source from its type's segments.
+ * @param {object} pPrompt - the prompt record
+ * @param {object} pType - the resolved prompt type
+ * @param {object} [pOptions] - { IncludeTitleHeading: true, SegmentHeadingLevel: 2 }
+ * @returns {string} markdown with template expressions intact
+ */
+function assembleSource(pPrompt, pType, pOptions)
+{
+	let tmpOptions = pOptions || {};
+	let tmpIncludeTitle = (typeof tmpOptions.IncludeTitleHeading === 'undefined') ? true : !!tmpOptions.IncludeTitleHeading;
+	let tmpHeading = '#'.repeat(Math.max(1, Math.min(6, Number(tmpOptions.SegmentHeadingLevel) || 2)));
+	let tmpSegments = (pType && Array.isArray(pType.Segments)) ? pType.Segments : [];
+	let tmpBodies = (pPrompt && pPrompt.Segments) ? pPrompt.Segments : {};
+
+	let tmpParts = [];
+	if (tmpIncludeTitle && pPrompt && pPrompt.Title)
+	{
+		tmpParts.push('# ' + String(pPrompt.Title).trim());
+	}
+
+	for (let i = 0; i < tmpSegments.length; i++)
+	{
+		let tmpSegment = tmpSegments[i];
+		let tmpBody = tmpSegment.Fixed ? String(tmpSegment.Body || '') : String(tmpBodies[tmpSegment.Key] || '');
+		tmpBody = tmpBody.trim();
+		if (!tmpBody)
+		{
+			if (tmpSegment.Optional || tmpSegment.Fixed) { continue; }
+			tmpBody = '(nothing written for this segment yet)';
+		}
+		tmpParts.push(tmpHeading + ' ' + String(tmpSegment.Name || tmpSegment.Key) + '\n\n' + tmpBody);
+	}
+
+	return tmpParts.join('\n\n') + '\n';
+}
+
+/**
+ * Build the { lowercased name -> Entries } map generate() feeds the
+ * {~WordListEntry:~} expression.
+ * @param {Array} pWordLists - word list records
+ * @returns {object}
+ */
+function wordListMap(pWordLists)
+{
+	let tmpMap = {};
+	(pWordLists || []).forEach((pList) =>
+	{
+		let tmpName = String(pList.Name || '').trim().toLowerCase();
+		if (tmpName) { tmpMap[tmpName] = pList.Entries || []; }
+	});
+	return tmpMap;
+}
+
+/**
+ * One concrete generation: parse the assembled source through the pict
+ * template engine with the word lists riding in the data record.
+ * @param {object} pPict - the pict instance (its template engine does the work)
+ * @param {object} pPrompt - the prompt record
+ * @param {object} pType - the resolved prompt type
+ * @param {Array} pWordLists - word list records in play
+ * @param {object} [pOptions] - assembleSource options + { RandomFunction }
+ * @returns {string} resolved markdown
+ */
+function generate(pPict, pPrompt, pType, pWordLists, pOptions)
+{
+	let tmpOptions = pOptions || {};
+	let tmpSource = assembleSource(pPrompt, pType, tmpOptions);
+	let tmpData =
+	{
+		Prompt: pPrompt,
+		__PromptEditorWordLists: wordListMap(pWordLists),
+		__PromptEditorRandom: (typeof tmpOptions.RandomFunction === 'function') ? tmpOptions.RandomFunction : undefined
+	};
+	return pPict.parseTemplate(tmpSource, tmpData, null, []);
+}
+
+/**
+ * The zip entry filename for one generated prompt.
+ * @param {object} pGenerated - the generated record
+ * @returns {string}
+ */
+function generatedFileName(pGenerated)
+{
+	let tmpSequence = String(Number(pGenerated.Sequence) || 0).padStart(3, '0');
+	return slug(pGenerated.PromptTitle) + '-' + tmpSequence + '.md';
+}
+
+module.exports = { assembleSource, generate, wordListMap, slug, generatedFileName };

package/source/providers/PromptProvider-Base.js

@@ -0,0 +1,302 @@
+'use strict';
+
+/**
+ * The data seam for pict-section-prompteditor.
+ *
+ * PromptDataProvider is the interface a host implements to map prompts, word
+ * lists, and generated output onto its own back end (a REST API, meadow
+ * entities, local storage, whatever). InMemoryPromptProvider is the default:
+ * everything lives in a plain object store (usually a node of pict AppData),
+ * so the section works with no server at all.
+ *
+ * Three record families:
+ *
+ *   WordList   { Key, Name, Entries: [[word, weight], ...], CreatedAt, UpdatedAt }
+ *     A curated word matrix. Weights default to 1; an entry's chance of being
+ *     drawn by {~WordListEntry:Name~} is weight / sum(weights).
+ *
+ *   Prompt     { Key, Title, TypeKey, Segments: { segmentKey: markdown },
+ *                Author, Meta, CreatedAt, UpdatedAt }
+ *     A crafted prompt. Segments hold the markdown for each of the prompt
+ *     type's segments, keyed by segment Key. Meta is an opaque object the
+ *     provider round-trips untouched -- the seam where a host hangs ratings,
+ *     version pointers, or anything else.
+ *
+ *   Generated  { Key, PromptKey, PromptTitle, TypeKey, Markdown, Sequence,
+ *                Author, GeneratedAt }
+ *     One concrete generation of a prompt: the assembled markdown with every
+ *     template expression (word lists included) resolved.
+ *
+ * All primitives return Promises so a remote provider drops in cleanly.
+ */
+
+/**
+ * Normalize a word list's Entries into [[word, weight], ...] pairs. Accepts
+ * pairs, bare strings, or {Word, Weight} objects; weights default to 1 and
+ * coerce to a non-negative number.
+ * @param {Array} pEntries
+ * @returns {Array<Array>}
+ */
+function normalizeEntries(pEntries)
+{
+	if (!Array.isArray(pEntries)) { return []; }
+	let tmpOut = [];
+	for (let i = 0; i < pEntries.length; i++)
+	{
+		let tmpEntry = pEntries[i];
+		let tmpWord = '';
+		let tmpWeight = 1;
+		if (Array.isArray(tmpEntry))
+		{
+			tmpWord = String(tmpEntry[0] == null ? '' : tmpEntry[0]);
+			tmpWeight = (typeof tmpEntry[1] === 'undefined' || tmpEntry[1] === null || tmpEntry[1] === '') ? 1 : Number(tmpEntry[1]);
+		}
+		else if (tmpEntry && typeof tmpEntry === 'object')
+		{
+			tmpWord = String(tmpEntry.Word == null ? '' : tmpEntry.Word);
+			tmpWeight = (typeof tmpEntry.Weight === 'undefined' || tmpEntry.Weight === null || tmpEntry.Weight === '') ? 1 : Number(tmpEntry.Weight);
+		}
+		else
+		{
+			tmpWord = String(tmpEntry == null ? '' : tmpEntry);
+		}
+		if (!isFinite(tmpWeight) || tmpWeight < 0) { tmpWeight = 1; }
+		tmpOut.push([tmpWord, tmpWeight]);
+	}
+	return tmpOut;
+}
+
+class PromptDataProvider
+{
+	constructor(pOptions)
+	{
+		this.options = pOptions || {};
+		this._now = (typeof this.options.Now === 'function') ? this.options.Now : Date.now;
+		let tmpCounter = 0;
+		this._key = (typeof this.options.KeyGenerator === 'function') ? this.options.KeyGenerator : (pPrefix) =>
+		{
+			tmpCounter++;
+			return (pPrefix || 'pe') + '_' + this._now().toString(36) + '_' + tmpCounter.toString(36) + '_' + Math.floor(Math.random() * 1679616).toString(36);
+		};
+	}
+
+	/* eslint-disable no-unused-vars */
+	// ---- word lists ---------------------------------------------------------
+	listWordLists() { return Promise.reject(new Error('listWordLists not implemented')); }
+	createWordList(pDraft) { return Promise.reject(new Error('createWordList not implemented')); }
+	updateWordList(pKey, pPatch) { return Promise.reject(new Error('updateWordList not implemented')); }
+	deleteWordList(pKey) { return Promise.reject(new Error('deleteWordList not implemented')); }
+
+	// ---- prompts ------------------------------------------------------------
+	listPrompts() { return Promise.reject(new Error('listPrompts not implemented')); }
+	createPrompt(pDraft) { return Promise.reject(new Error('createPrompt not implemented')); }
+	updatePrompt(pKey, pPatch) { return Promise.reject(new Error('updatePrompt not implemented')); }
+	deletePrompt(pKey) { return Promise.reject(new Error('deletePrompt not implemented')); }
+
+	// ---- generated output ---------------------------------------------------
+	listGenerated(pPromptKey) { return Promise.reject(new Error('listGenerated not implemented')); }
+	createGenerated(pDraft) { return Promise.reject(new Error('createGenerated not implemented')); }
+	deleteGenerated(pKey) { return Promise.reject(new Error('deleteGenerated not implemented')); }
+	clearGenerated(pPromptKey) { return Promise.reject(new Error('clearGenerated not implemented')); }
+	/* eslint-enable no-unused-vars */
+
+	// ---- conveniences built on the primitives -------------------------------
+	/**
+	 * Load everything the section renders, in one call.
+	 * @returns {Promise<{WordLists: Array, Prompts: Array, Generated: Array}>}
+	 */
+	loadAll()
+	{
+		return Promise.all([this.listWordLists(), this.listPrompts(), this.listGenerated()])
+			.then((pResults) => ({ WordLists: pResults[0], Prompts: pResults[1], Generated: pResults[2] }));
+	}
+
+	/**
+	 * Find a word list by Name (trimmed, case-insensitive). The lookup the
+	 * {~WordListEntry:Name~} expression leans on.
+	 * @param {string} pName
+	 * @returns {Promise<object|null>}
+	 */
+	getWordListByName(pName)
+	{
+		let tmpWanted = String(pName || '').trim().toLowerCase();
+		return this.listWordLists().then((pLists) =>
+			pLists.find((pList) => String(pList.Name || '').trim().toLowerCase() === tmpWanted) || null);
+	}
+}
+
+class InMemoryPromptProvider extends PromptDataProvider
+{
+	constructor(pOptions)
+	{
+		super(pOptions);
+		// The store is usually a node of pict AppData (so state is observable
+		// and survives view re-renders); a fresh object works fine too.
+		let tmpStore = (this.options && this.options.Store) ? this.options.Store : {};
+		if (!tmpStore.WordLists) { tmpStore.WordLists = {}; }
+		if (!tmpStore.Prompts) { tmpStore.Prompts = {}; }
+		if (!tmpStore.Generated) { tmpStore.Generated = {}; }
+		this.store = tmpStore;
+	}
+
+	_clone(pValue) { return (pValue == null) ? pValue : JSON.parse(JSON.stringify(pValue)); }
+
+	// ---- word lists ---------------------------------------------------------
+	listWordLists()
+	{
+		let tmpLists = Object.values(this.store.WordLists).map((pList) => this._clone(pList));
+		tmpLists.sort((pA, pB) => String(pA.Name).localeCompare(String(pB.Name)));
+		return Promise.resolve(tmpLists);
+	}
+
+	createWordList(pDraft)
+	{
+		let tmpDraft = pDraft || {};
+		let tmpName = String(tmpDraft.Name || '').trim();
+		if (!tmpName) { return Promise.reject(new Error('A word list needs a Name.')); }
+		let tmpNow = this._now();
+		let tmpList =
+		{
+			Key: tmpDraft.Key || this._key('wl'),
+			Name: tmpName,
+			Entries: normalizeEntries(tmpDraft.Entries),
+			CreatedAt: tmpNow,
+			UpdatedAt: tmpNow
+		};
+		this.store.WordLists[tmpList.Key] = tmpList;
+		return Promise.resolve(this._clone(tmpList));
+	}
+
+	updateWordList(pKey, pPatch)
+	{
+		let tmpList = this.store.WordLists[pKey];
+		if (!tmpList) { return Promise.reject(new Error('No word list with Key ' + pKey)); }
+		let tmpPatch = pPatch || {};
+		if (typeof tmpPatch.Name !== 'undefined')
+		{
+			let tmpName = String(tmpPatch.Name || '').trim();
+			if (!tmpName) { return Promise.reject(new Error('A word list needs a Name.')); }
+			tmpList.Name = tmpName;
+		}
+		if (typeof tmpPatch.Entries !== 'undefined') { tmpList.Entries = normalizeEntries(tmpPatch.Entries); }
+		tmpList.UpdatedAt = this._now();
+		return Promise.resolve(this._clone(tmpList));
+	}
+
+	deleteWordList(pKey)
+	{
+		delete this.store.WordLists[pKey];
+		return Promise.resolve();
+	}
+
+	// ---- prompts ------------------------------------------------------------
+	listPrompts()
+	{
+		let tmpPrompts = Object.values(this.store.Prompts).map((pPrompt) => this._clone(pPrompt));
+		tmpPrompts.sort((pA, pB) => (pB.UpdatedAt || 0) - (pA.UpdatedAt || 0));
+		return Promise.resolve(tmpPrompts);
+	}
+
+	createPrompt(pDraft)
+	{
+		let tmpDraft = pDraft || {};
+		if (!tmpDraft.TypeKey) { return Promise.reject(new Error('A prompt needs a TypeKey.')); }
+		let tmpNow = this._now();
+		let tmpPrompt =
+		{
+			Key: tmpDraft.Key || this._key('pr'),
+			Title: String(tmpDraft.Title || 'Untitled prompt'),
+			TypeKey: String(tmpDraft.TypeKey),
+			Segments: (tmpDraft.Segments && typeof tmpDraft.Segments === 'object') ? this._clone(tmpDraft.Segments) : {},
+			Author: tmpDraft.Author || null,
+			Meta: (typeof tmpDraft.Meta === 'undefined') ? {} : this._clone(tmpDraft.Meta),
+			CreatedAt: tmpNow,
+			UpdatedAt: tmpNow
+		};
+		this.store.Prompts[tmpPrompt.Key] = tmpPrompt;
+		return Promise.resolve(this._clone(tmpPrompt));
+	}
+
+	updatePrompt(pKey, pPatch)
+	{
+		let tmpPrompt = this.store.Prompts[pKey];
+		if (!tmpPrompt) { return Promise.reject(new Error('No prompt with Key ' + pKey)); }
+		let tmpPatch = pPatch || {};
+		if (typeof tmpPatch.Title !== 'undefined') { tmpPrompt.Title = String(tmpPatch.Title); }
+		if (typeof tmpPatch.TypeKey !== 'undefined') { tmpPrompt.TypeKey = String(tmpPatch.TypeKey); }
+		if (typeof tmpPatch.Segments !== 'undefined') { tmpPrompt.Segments = this._clone(tmpPatch.Segments || {}); }
+		if (typeof tmpPatch.Meta !== 'undefined') { tmpPrompt.Meta = this._clone(tmpPatch.Meta); }
+		tmpPrompt.UpdatedAt = this._now();
+		return Promise.resolve(this._clone(tmpPrompt));
+	}
+
+	deletePrompt(pKey)
+	{
+		delete this.store.Prompts[pKey];
+		// Generated output belongs to its prompt; remove it alongside.
+		for (let tmpGenKey of Object.keys(this.store.Generated))
+		{
+			if (this.store.Generated[tmpGenKey].PromptKey === pKey) { delete this.store.Generated[tmpGenKey]; }
+		}
+		return Promise.resolve();
+	}
+
+	// ---- generated output ---------------------------------------------------
+	listGenerated(pPromptKey)
+	{
+		let tmpGenerated = Object.values(this.store.Generated)
+			.filter((pGen) => !pPromptKey || pGen.PromptKey === pPromptKey)
+			.map((pGen) => this._clone(pGen));
+		// Ordered like a file listing: the prompt with the most recent
+		// generation first, and within a prompt the files in sequence order
+		// (001 at the top), matching the names they get in the zip.
+		let tmpLatestByPrompt = {};
+		tmpGenerated.forEach((pGen) =>
+		{
+			let tmpStamp = pGen.GeneratedAt || 0;
+			if (!(pGen.PromptKey in tmpLatestByPrompt) || tmpStamp > tmpLatestByPrompt[pGen.PromptKey]) { tmpLatestByPrompt[pGen.PromptKey] = tmpStamp; }
+		});
+		tmpGenerated.sort((pA, pB) =>
+			(tmpLatestByPrompt[pB.PromptKey] - tmpLatestByPrompt[pA.PromptKey])
+			|| String(pA.PromptKey).localeCompare(String(pB.PromptKey))
+			|| (pA.Sequence || 0) - (pB.Sequence || 0)
+			|| (pA.GeneratedAt || 0) - (pB.GeneratedAt || 0));
+		return Promise.resolve(tmpGenerated);
+	}
+
+	createGenerated(pDraft)
+	{
+		let tmpDraft = pDraft || {};
+		if (!tmpDraft.PromptKey) { return Promise.reject(new Error('Generated output needs a PromptKey.')); }
+		let tmpGenerated =
+		{
+			Key: tmpDraft.Key || this._key('gen'),
+			PromptKey: tmpDraft.PromptKey,
+			PromptTitle: String(tmpDraft.PromptTitle || ''),
+			TypeKey: String(tmpDraft.TypeKey || ''),
+			Markdown: String(tmpDraft.Markdown || ''),
+			Sequence: Number(tmpDraft.Sequence) || 0,
+			Author: tmpDraft.Author || null,
+			GeneratedAt: this._now()
+		};
+		this.store.Generated[tmpGenerated.Key] = tmpGenerated;
+		return Promise.resolve(this._clone(tmpGenerated));
+	}
+
+	deleteGenerated(pKey)
+	{
+		delete this.store.Generated[pKey];
+		return Promise.resolve();
+	}
+
+	clearGenerated(pPromptKey)
+	{
+		for (let tmpKey of Object.keys(this.store.Generated))
+		{
+			if (!pPromptKey || this.store.Generated[tmpKey].PromptKey === pPromptKey) { delete this.store.Generated[tmpKey]; }
+		}
+		return Promise.resolve();
+	}
+}
+
+module.exports = { PromptDataProvider, InMemoryPromptProvider, normalizeEntries };