@grainulation/mill 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+## 1.0.0
+
+Initial release.
+
+- 24 export formats (CSV, Markdown, JSON-LD, NDJSON, BibTeX, RIS, YAML, SQL, GraphML, DOT, and more)
+- Web workbench UI with format preview, copy, and download
+- SSE live-reload when source files change
+- `mill serve` with `--source` flag for cross-directory compilation reading
+- `mill export`, `mill convert`, `mill publish`, `mill formats` CLI commands
+- Zero runtime dependencies

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 grainulation contributors
+
+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,76 @@
+# mill
+
+Turn sprint evidence into shareable artifacts.
+
+## Quick start
+
+```bash
+# Export a brief to PDF
+npx @grainulation/mill export --format pdf output/brief.html
+
+# Claims to CSV
+npx @grainulation/mill export --format csv claims.json
+
+# HTML to clean Markdown
+npx @grainulation/mill convert --from html --to markdown output/brief.html
+
+# Build a static site from sprint outputs
+npx @grainulation/mill publish --target static output/
+
+# Claims to JSON-LD
+npx @grainulation/mill export --format json-ld claims.json -o claims.jsonld
+
+# Copy to clipboard
+npx @grainulation/mill publish --target clipboard output/brief.html
+```
+
+## Export formats
+
+24 built-in formats in `lib/formats/`. Most commonly used:
+
+| Format | Input | Output | Notes |
+|--------|-------|--------|-------|
+| `pdf` | HTML, Markdown | PDF | Uses `npx md-to-pdf` or puppeteer |
+| `csv` | claims.json | CSV | Flat columns, semicolon-joined tags |
+| `markdown` | HTML | Markdown | Zero-dep tag stripping, handles wheat output |
+| `json-ld` | claims.json | JSON-LD | schema.org vocab, wheat namespace |
+| `html-report` | claims.json | HTML | Self-contained interactive report |
+| `slide-deck` | claims.json | HTML | Scroll-snap presentation |
+| `github-issues` | claims.json | JSON | GitHub Issues payloads |
+| `jira-csv` | claims.json | CSV | Jira-compatible import |
+| `yaml` | claims.json | YAML | YAML export |
+| `ndjson` | claims.json | NDJSON | Newline-delimited JSON |
+
+Run `mill formats` to see all 24 formats and publish targets.
+
+## Publish targets
+
+| Target | Input | Output | Notes |
+|--------|-------|--------|-------|
+| `static` | directory | `_site/` | Dark-themed index + copied artifacts |
+| `clipboard` | file or dir | clipboard | Uses pbcopy/xclip/clip |
+
+## Zero dependencies
+
+Mill has no installed npm dependencies. Heavy operations (PDF generation) run via `npx` on demand, pulling packages only when needed.
+
+## Works standalone
+
+Mill reads sprint output files directly. It does not require wheat to be installed -- give it HTML, Markdown, or claims JSON and it produces shareable formats.
+
+## CLI reference
+
+```
+mill export    --format <fmt> <file>              Export to target format
+mill publish   --target <dest> <dir>              Publish sprint outputs
+mill convert   --from <fmt> --to <fmt> <file>     Convert between formats
+mill formats                                      List available formats
+mill serve     [--port 9094] [--source <dir>]     Start the export workbench UI
+mill serve-mcp                                    Start the MCP server on stdio
+```
+
+All commands accept `-o <path>` to set the output location.
+
+## License
+
+MIT

package/bin/mill.js

@@ -0,0 +1,320 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const path = require('node:path');
+const { parseArgs } = require('node:util');
+const { fork } = require('node:child_process');
+
+const LIB_DIR = path.join(__dirname, '..', 'lib');
+
+// --version / -v: print version and exit
+if (process.argv.includes('--version') || process.argv.includes('-v')) {
+  const pkg = require(path.join(__dirname, '..', 'package.json'));
+  console.log(pkg.version);
+  process.exit(0);
+}
+
+const verbose = process.argv.includes('--verbose');
+function vlog(...a) {
+  if (!verbose) return;
+  const ts = new Date().toISOString();
+  process.stderr.write(`[${ts}] mill: ${a.join(' ')}\n`);
+}
+
+const COMMANDS = {
+  export: { description: 'Export artifacts to a target format', handler: runExport },
+  publish: { description: 'Publish sprint outputs to a destination', handler: runPublish },
+  convert: { description: 'Convert between artifact formats', handler: runConvert },
+  formats: { description: 'List available export formats', handler: runFormats },
+  serve: { description: 'Start the export workbench UI', handler: runServe },
+  'serve-mcp': { description: 'Start the MCP server on stdio', handler: null },
+};
+
+const USAGE = `
+mill -- turn sprint evidence into shareable artifacts
+
+Usage:
+  mill serve   [--port 9094] [--source <dir>]  Start the export workbench UI
+  mill serve-mcp                               Start the MCP server on stdio
+  mill export  --format <fmt> <file>           Export artifact to target format
+  mill publish --target <dest> <dir>           Publish sprint outputs
+  mill convert --from <fmt> --to <fmt> <file>  Convert between formats
+  mill formats                                 List available formats
+
+Export formats:
+  pdf        HTML or Markdown to PDF (via npx md-to-pdf)
+  csv        Claims JSON to CSV
+  markdown   HTML artifacts to clean Markdown
+  json-ld    Claims JSON to JSON-LD for semantic web
+
+Publish targets:
+  static     Generate a static site from sprint outputs
+  clipboard  Copy formatted output to system clipboard
+
+Examples:
+  npx @grainulation/mill serve --port 9094 --source /path/to/sprint
+  npx @grainulation/mill export --format pdf output/brief.html
+  npx @grainulation/mill export --format csv claims.json
+  npx @grainulation/mill export --format json-ld claims.json -o claims.jsonld
+  npx @grainulation/mill publish --target static output/
+  npx @grainulation/mill convert --from html --to markdown output/brief.html
+`.trim();
+
+function main() {
+  const args = process.argv.slice(2);
+
+  vlog('startup', `command=${args[0] || '(none)'}`, `cwd=${process.cwd()}`);
+
+  if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+    console.log(USAGE);
+    process.exit(0);
+  }
+
+  const command = args[0];
+  const handler = COMMANDS[command];
+
+  if (command === 'help') {
+    console.log(USAGE);
+    process.exit(0);
+  }
+
+  // serve command forks the ESM server module
+  if (command === 'serve') {
+    runServe(args.slice(1));
+    return;
+  }
+
+  // serve-mcp command starts the MCP server on stdio
+  if (command === 'serve-mcp') {
+    const serveMcp = require('../lib/serve-mcp.js');
+    serveMcp.run(process.cwd());
+    return;
+  }
+
+  if (!handler) {
+    console.error(`mill: unknown command: ${command}`);
+    console.error(`Run "mill --help" for usage.`);
+    process.exit(1);
+  }
+
+  handler.handler(args.slice(1));
+}
+
+async function runExport(args) {
+  let values, positionals;
+  try {
+    ({ values, positionals } = parseArgs({
+      args,
+      options: {
+        format: { type: 'string', short: 'f' },
+        output: { type: 'string', short: 'o' },
+        json: { type: 'boolean', default: false },
+      },
+      allowPositionals: true,
+    }));
+  } catch (err) {
+    if (err.code === 'ERR_PARSE_ARGS_UNKNOWN_OPTION') {
+      const flag = err.message.match(/option "([^"]+)"/)?.[1] || 'unknown';
+      console.error(`mill: unknown option: ${flag}. Run "mill export --help" for usage.`);
+      process.exit(1);
+    }
+    throw err;
+  }
+
+  if (!values.format) {
+    console.error('mill: missing --format. Options: pdf, csv, markdown, json-ld');
+    process.exit(1);
+  }
+
+  const inputFile = positionals[0];
+  if (!inputFile) {
+    console.error('mill: missing input file.');
+    process.exit(1);
+  }
+
+  const inputPath = path.resolve(inputFile);
+  const format = values.format;
+  const outputPath = values.output
+    ? path.resolve(values.output)
+    : null;
+
+  const formats = require('../lib/formats.js');
+  const exporter = formats.getExporter(format);
+
+  if (!exporter) {
+    console.error(`mill: unknown format: ${format}`);
+    console.error(`Available: ${formats.listExportFormats().join(', ')}`);
+    process.exit(1);
+  }
+
+  try {
+    const result = await exporter.export(inputPath, outputPath);
+    if (values.json) {
+      console.log(JSON.stringify(result));
+    } else {
+      console.log(result.message);
+    }
+  } catch (err) {
+    if (values.json) {
+      console.log(JSON.stringify({ error: err.message }));
+    } else {
+      console.error(`mill: export failed: ${err.message}`);
+    }
+    process.exit(1);
+  }
+}
+
+async function runPublish(args) {
+  let values, positionals;
+  try {
+    ({ values, positionals } = parseArgs({
+      args,
+      options: {
+        target: { type: 'string', short: 't' },
+        output: { type: 'string', short: 'o' },
+        json: { type: 'boolean', default: false },
+      },
+      allowPositionals: true,
+    }));
+  } catch (err) {
+    if (err.code === 'ERR_PARSE_ARGS_UNKNOWN_OPTION') {
+      const flag = err.message.match(/option "([^"]+)"/)?.[1] || 'unknown';
+      console.error(`mill: unknown option: ${flag}. Run "mill publish --help" for usage.`);
+      process.exit(1);
+    }
+    throw err;
+  }
+
+  if (!values.target) {
+    console.error('mill: missing --target. Options: static, clipboard');
+    process.exit(1);
+  }
+
+  const inputDir = positionals[0];
+  if (!inputDir) {
+    console.error('mill: missing input directory.');
+    process.exit(1);
+  }
+
+  const inputPath = path.resolve(inputDir);
+  const target = values.target;
+  const outputPath = values.output ? path.resolve(values.output) : null;
+
+  const formats = require('../lib/formats.js');
+  const publisher = formats.getPublisher(target);
+
+  if (!publisher) {
+    console.error(`mill: unknown target: ${target}`);
+    console.error(`Available: ${formats.listPublishTargets().join(', ')}`);
+    process.exit(1);
+  }
+
+  try {
+    const result = await publisher.publish(inputPath, outputPath);
+    if (values.json) {
+      console.log(JSON.stringify(result));
+    } else {
+      console.log(result.message);
+    }
+  } catch (err) {
+    if (values.json) {
+      console.log(JSON.stringify({ error: err.message }));
+    } else {
+      console.error(`mill: publish failed: ${err.message}`);
+    }
+    process.exit(1);
+  }
+}
+
+async function runConvert(args) {
+  let values, positionals;
+  try {
+    ({ values, positionals } = parseArgs({
+      args,
+      options: {
+        from: { type: 'string' },
+        to: { type: 'string' },
+        output: { type: 'string', short: 'o' },
+        json: { type: 'boolean', default: false },
+      },
+      allowPositionals: true,
+    }));
+  } catch (err) {
+    if (err.code === 'ERR_PARSE_ARGS_UNKNOWN_OPTION') {
+      const flag = err.message.match(/option "([^"]+)"/)?.[1] || 'unknown';
+      console.error(`mill: unknown option: ${flag}. Run "mill convert --help" for usage.`);
+      process.exit(1);
+    }
+    throw err;
+  }
+
+  if (!values.from || !values.to) {
+    console.error('mill: missing --from and/or --to format.');
+    process.exit(1);
+  }
+
+  const inputFile = positionals[0];
+  if (!inputFile) {
+    console.error('mill: missing input file.');
+    process.exit(1);
+  }
+
+  const inputPath = path.resolve(inputFile);
+  const outputPath = values.output ? path.resolve(values.output) : null;
+
+  // Convert is sugar: detect source, export to target
+  const formats = require('../lib/formats.js');
+  const exporter = formats.getExporter(values.to);
+
+  if (!exporter) {
+    console.error(`mill: unknown target format: ${values.to}`);
+    process.exit(1);
+  }
+
+  try {
+    const result = await exporter.export(inputPath, outputPath);
+    if (values.json) {
+      console.log(JSON.stringify(result));
+    } else {
+      console.log(result.message);
+    }
+  } catch (err) {
+    if (values.json) {
+      console.log(JSON.stringify({ error: err.message }));
+    } else {
+      console.error(`mill: convert failed: ${err.message}`);
+    }
+    process.exit(1);
+  }
+}
+
+function runFormats(args) {
+  const jsonMode = (args || []).includes('--json');
+  const formats = require('../lib/formats.js');
+  if (jsonMode) {
+    console.log(JSON.stringify({
+      export_formats: formats.listExportFormats(),
+      publish_targets: formats.listPublishTargets(),
+    }));
+    return;
+  }
+  console.log('Export formats:');
+  for (const f of formats.listExportFormats()) {
+    console.log(`  ${f}`);
+  }
+  console.log('\nPublish targets:');
+  for (const t of formats.listPublishTargets()) {
+    console.log(`  ${t}`);
+  }
+}
+
+function runServe(args) {
+  const serverPath = path.join(LIB_DIR, 'server.js');
+  const child = fork(serverPath, args, { stdio: 'inherit' });
+  child.on('exit', (code) => process.exit(code ?? 0));
+  process.on('SIGTERM', () => child.kill('SIGTERM'));
+  process.on('SIGINT', () => child.kill('SIGINT'));
+}
+
+main();

package/lib/exporters/csv.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+/**
+ * Export claims.json to CSV.
+ * Handles nested fields by flattening to dot-notation columns.
+ */
+
+const CSV_COLUMNS = [
+  'id',
+  'type',
+  'text',
+  'confidence',
+  'evidence_tier',
+  'source',
+  'status',
+  'created',
+  'tags',
+];
+
+function escapeCsvField(value) {
+  if (value == null) return '';
+  let str = String(value);
+  // CWE-1236: Prevent CSV injection by prefixing formula-triggering characters
+  if (/^[=+\-@\t\r]/.test(str)) {
+    str = "'" + str;
+  }
+  if (str.includes(',') || str.includes('"') || str.includes('\n')) {
+    return `"${str.replace(/"/g, '""')}"`;
+  }
+  return str;
+}
+
+function claimToRow(claim) {
+  return CSV_COLUMNS.map((col) => {
+    if (col === 'tags') {
+      return escapeCsvField(Array.isArray(claim.tags) ? claim.tags.join('; ') : '');
+    }
+    if (col === 'evidence_tier') {
+      return escapeCsvField(claim.evidence?.tier ?? claim.evidence_tier ?? '');
+    }
+    if (col === 'source') {
+      return escapeCsvField(claim.evidence?.source ?? claim.source ?? '');
+    }
+    return escapeCsvField(claim[col]);
+  }).join(',');
+}
+
+function deriveOutputPath(inputPath, explicit) {
+  if (explicit) return explicit;
+  const dir = path.dirname(inputPath);
+  const base = path.basename(inputPath, path.extname(inputPath));
+  return path.join(dir, `${base}.csv`);
+}
+
+async function exportCsv(inputPath, outputPath) {
+  const raw = fs.readFileSync(inputPath, 'utf-8');
+  const data = JSON.parse(raw);
+
+  // Accept either an array or { claims: [...] }
+  const claims = Array.isArray(data) ? data : (data.claims || []);
+
+  if (claims.length === 0) {
+    throw new Error('No claims found in input file.');
+  }
+
+  const header = CSV_COLUMNS.join(',');
+  const rows = claims.map(claimToRow);
+  const csv = [header, ...rows].join('\n') + '\n';
+
+  const out = deriveOutputPath(inputPath, outputPath);
+  fs.writeFileSync(out, csv, 'utf-8');
+
+  return { outputPath: out, message: `CSV written to ${out} (${claims.length} claims)` };
+}
+
+module.exports = {
+  name: 'csv',
+  description: 'Export claims JSON to CSV',
+  export: exportCsv,
+};

package/lib/exporters/json-ld.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { buildReport } = require('../json-ld-common.js');
+
+/**
+ * Export claims.json to JSON-LD format.
+ * Uses shared schema.org/Report vocabulary from json-ld-common.js.
+ */
+
+function deriveOutputPath(inputPath, explicit) {
+  if (explicit) return explicit;
+  const dir = path.dirname(inputPath);
+  const base = path.basename(inputPath, path.extname(inputPath));
+  return path.join(dir, `${base}.jsonld`);
+}
+
+async function exportJsonLd(inputPath, outputPath) {
+  const raw = fs.readFileSync(inputPath, 'utf-8');
+  const data = JSON.parse(raw);
+  const claims = Array.isArray(data) ? data : (data.claims || []);
+
+  if (claims.length === 0) {
+    throw new Error('No claims found in input file.');
+  }
+
+  const meta = data.meta || { sprint: 'unknown', question: 'Wheat Sprint Claims' };
+  const certificate = data.certificate || {};
+  const doc = buildReport(meta, claims, certificate);
+
+  const out = deriveOutputPath(inputPath, outputPath);
+  const tmp = out + '.tmp.' + process.pid;
+  fs.writeFileSync(tmp, JSON.stringify(doc, null, 2) + '\n', 'utf-8');
+  fs.renameSync(tmp, out);
+
+  return { outputPath: out, message: `JSON-LD written to ${out} (${claims.length} claims)` };
+}
+
+module.exports = {
+  name: 'json-ld',
+  description: 'Export claims JSON to JSON-LD for semantic web',
+  export: exportJsonLd,
+};

package/lib/exporters/markdown.js

@@ -0,0 +1,116 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+/**
+ * Convert HTML artifacts to clean Markdown.
+ * Uses a minimal tag-stripping approach -- no dependencies.
+ * Handles the common patterns from wheat sprint HTML output.
+ */
+
+function htmlToMarkdown(html) {
+  let md = html;
+
+  // Remove doctype, head, scripts, styles
+  md = md.replace(/<!DOCTYPE[^>]*>/gi, '');
+  md = md.replace(/<head[\s\S]*?<\/head>/gi, '');
+  md = md.replace(/<script[\s\S]*?<\/script>/gi, '');
+  md = md.replace(/<style[\s\S]*?<\/style>/gi, '');
+
+  // Headings
+  md = md.replace(/<h1[^>]*>([\s\S]*?)<\/h1>/gi, (_, c) => `# ${strip(c)}\n\n`);
+  md = md.replace(/<h2[^>]*>([\s\S]*?)<\/h2>/gi, (_, c) => `## ${strip(c)}\n\n`);
+  md = md.replace(/<h3[^>]*>([\s\S]*?)<\/h3>/gi, (_, c) => `### ${strip(c)}\n\n`);
+  md = md.replace(/<h4[^>]*>([\s\S]*?)<\/h4>/gi, (_, c) => `#### ${strip(c)}\n\n`);
+  md = md.replace(/<h5[^>]*>([\s\S]*?)<\/h5>/gi, (_, c) => `##### ${strip(c)}\n\n`);
+  md = md.replace(/<h6[^>]*>([\s\S]*?)<\/h6>/gi, (_, c) => `###### ${strip(c)}\n\n`);
+
+  // Bold, italic, code
+  md = md.replace(/<strong[^>]*>([\s\S]*?)<\/strong>/gi, '**$1**');
+  md = md.replace(/<b[^>]*>([\s\S]*?)<\/b>/gi, '**$1**');
+  md = md.replace(/<em[^>]*>([\s\S]*?)<\/em>/gi, '*$1*');
+  md = md.replace(/<i[^>]*>([\s\S]*?)<\/i>/gi, '*$1*');
+  md = md.replace(/<code[^>]*>([\s\S]*?)<\/code>/gi, '`$1`');
+
+  // Pre/code blocks
+  md = md.replace(/<pre[^>]*><code[^>]*>([\s\S]*?)<\/code><\/pre>/gi, (_, c) => {
+    return '\n```\n' + decodeEntities(c) + '\n```\n\n';
+  });
+  md = md.replace(/<pre[^>]*>([\s\S]*?)<\/pre>/gi, (_, c) => {
+    return '\n```\n' + decodeEntities(c) + '\n```\n\n';
+  });
+
+  // Links
+  md = md.replace(/<a[^>]+href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi, '[$2]($1)');
+
+  // Images
+  md = md.replace(/<img[^>]+src="([^"]*)"[^>]*alt="([^"]*)"[^>]*\/?>/gi, '![$2]($1)');
+  md = md.replace(/<img[^>]+src="([^"]*)"[^>]*\/?>/gi, '![]($1)');
+
+  // Lists
+  md = md.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, (_, c) => `- ${strip(c).trim()}\n`);
+  md = md.replace(/<\/?[ou]l[^>]*>/gi, '\n');
+
+  // Paragraphs and breaks
+  md = md.replace(/<p[^>]*>([\s\S]*?)<\/p>/gi, (_, c) => `${strip(c).trim()}\n\n`);
+  md = md.replace(/<br\s*\/?>/gi, '\n');
+  md = md.replace(/<hr\s*\/?>/gi, '\n---\n\n');
+
+  // Blockquotes
+  md = md.replace(/<blockquote[^>]*>([\s\S]*?)<\/blockquote>/gi, (_, c) => {
+    return strip(c).trim().split('\n').map((l) => `> ${l}`).join('\n') + '\n\n';
+  });
+
+  // Strip remaining tags
+  md = md.replace(/<[^>]+>/g, '');
+
+  // Decode common entities
+  md = decodeEntities(md);
+
+  // Normalize whitespace
+  md = md.replace(/\n{3,}/g, '\n\n');
+  md = md.trim() + '\n';
+
+  return md;
+}
+
+function strip(html) {
+  return html.replace(/<[^>]+>/g, '');
+}
+
+function decodeEntities(str) {
+  return str
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/&nbsp;/g, ' ');
+}
+
+function deriveOutputPath(inputPath, explicit) {
+  if (explicit) return explicit;
+  const dir = path.dirname(inputPath);
+  const base = path.basename(inputPath, path.extname(inputPath));
+  return path.join(dir, `${base}.md`);
+}
+
+async function exportMarkdown(inputPath, outputPath) {
+  const html = fs.readFileSync(inputPath, 'utf-8');
+  const trimmed = html.trimStart();
+  if (!trimmed.startsWith('<') && !trimmed.startsWith('<!DOCTYPE') && !trimmed.startsWith('<html')) {
+    process.stderr.write('Warning: Input does not appear to be HTML. Markdown conversion may produce unexpected results.\n');
+  }
+  const md = htmlToMarkdown(html);
+  const out = deriveOutputPath(inputPath, outputPath);
+  fs.writeFileSync(out, md, 'utf-8');
+  return { outputPath: out, message: `Markdown written to ${out}` };
+}
+
+module.exports = {
+  name: 'markdown',
+  description: 'Convert HTML artifacts to clean Markdown',
+  export: exportMarkdown,
+  htmlToMarkdown,
+};