dsh-plugin-wiki-tools 0.7.0 → 0.9.0

package/index.js

@@ -16,6 +16,7 @@ import z from '@deepseek-ai/schemastery'
 import { Vault } from './lib/vault.js'
 import { quickView, searchVault } from './lib/search.js'
 import { lintVault } from './lib/lint.js'
+import { scaffoldVault, SCAFFOLD_MODES } from './lib/scaffold.js'
 
 export const name = 'wiki-tools'
 export const inject = ['tools']
@@ -215,6 +216,78 @@ export function createTools(vault, options = {}) {
     presentCall: args => ({ card: 'generic', title: `Rename wiki page: ${args.title} → ${args.new_title}`, kind: 'other', rawInput: { from: args.title, to: args.new_title } }),
   })
 
+  const wikiScaffold = defineTool({
+    name: 'wiki_scaffold',
+    description:
+      'Scaffold a wiki vault in one call: the chosen mode\u2019s folder structure with per-folder _index.md, '
+      + 'the core files (wiki/index.md, log.md, hot.md, overview.md), the mode\u2019s key seed pages, a raw-source '
+      + 'manifest, and the vault AGENTS.md conventions file. Idempotent — existing files are kept. Modes: '
+      + 'generic (matches wiki_write routing), sitemap, repository, business, personal, research, book. '
+      + 'The result carries a suggested typeFolders config for non-generic modes to paste into the profile.',
+    parameters: {
+      mode: {
+        type: 'string',
+        required: true,
+        enum: Object.keys(SCAFFOLD_MODES),
+        description: 'Scaffold mode; pick by what the vault is for (generic for a general knowledge base).',
+      },
+      purpose: {
+        type: 'string',
+        description: 'One-line vault purpose, written into overview.md and AGENTS.md.',
+      },
+    },
+    output: {
+      schema: {
+        type: 'object',
+        additionalProperties: true,
+      },
+      render: (_args, value) => [{
+        type: 'text',
+        text: typeof value === 'object' && value !== null && 'created' in value
+          ? `wiki_scaffold (${value.mode}): created ${value.created.length} files, skipped ${value.skipped.length} existing`
+            + (Object.keys(value.suggestedTypeFolders ?? {}).length > 0
+              ? `; suggested typeFolders: ${JSON.stringify(value.suggestedTypeFolders)}`
+              : '')
+          : 'wiki_scaffold: failed',
+      }],
+    },
+    async execute(args) {
+      return await scaffoldVault(vault.root, args)
+    },
+    presentCall: args => ({ card: 'generic', title: `Scaffold wiki vault (${args.mode})`, kind: 'other', rawInput: { mode: args.mode } }),
+  })
+
+  const wikiArchive = defineTool({
+    name: 'wiki_archive',
+    description:
+      'Archive one cold raw source: move it from .raw/ to .archive/ (same subpath, file kept on disk) '
+      + 'and drop its manifest entry so future ingests treat it as new. Use when a source is no longer '
+      + 'active but should not be deleted. Pages derived from it are untouched.',
+    parameters: {
+      source_path: {
+        type: 'string',
+        required: true,
+        description: 'Vault-relative .raw/ source path, e.g. .raw/articles/note.md.',
+      },
+    },
+    output: {
+      schema: {
+        type: 'object',
+        additionalProperties: true,
+      },
+      render: (_args, value) => [{
+        type: 'text',
+        text: typeof value === 'object' && value !== null && 'archivedTo' in value
+          ? 'wiki_archive: ' + value.archivedFrom + ' → ' + value.archivedTo + ' (manifest entry dropped)'
+          : 'wiki_archive: failed',
+      }],
+    },
+    async execute(args) {
+      return await vault.archiveSource({ sourcePath: args.source_path })
+    },
+    presentCall: args => ({ card: 'generic', title: 'Archive source: ' + args.source_path, kind: 'other', rawInput: { source: args.source_path } }),
+  })
+
   const wikiLint = defineTool({
     name: 'wiki_lint',
     description:
@@ -238,7 +311,7 @@ export function createTools(vault, options = {}) {
     presentCall: () => ({ card: 'generic', title: 'Lint wiki vault', kind: 'other' }),
   })
 
-  return [wikiQuery, wikiWrite, wikiRename, wikiLint]
+  return [wikiQuery, wikiWrite, wikiRename, wikiScaffold, wikiArchive, wikiLint]
 }
 
 /**

package/lib/bm25.js

@@ -0,0 +1,107 @@
+/**
+ * BM25 ranking over wiki pages, the retrieval core the wiki-retrieve skill
+ * describes. Latin text tokenizes on word boundaries; CJK runs tokenize into
+ * character bigrams (plus unigrams) so Chinese queries rank without a
+ * segmenter. Exact-phrase matching stays in search.js as a complementary
+ * signal: BM25 ranks term overlap, not contiguous text.
+ *
+ * @module dsh-plugin-wiki-tools/lib/bm25
+ */
+
+const K1 = 1.2
+const B = 0.75
+
+/**
+ * Tokenize text into ranking terms: latin words lowercased, CJK unigrams plus
+ * bigrams.
+ * @param {string} text - any text.
+ * @returns {string[]} terms in order.
+ */
+export function tokenize(text) {
+  const source = typeof text === 'string' ? text : ''
+  const terms = []
+  let buffer = ''
+  const flush = () => {
+    if (buffer.length > 0) {
+      terms.push(buffer.toLowerCase())
+      buffer = ''
+    }
+  }
+  for (let index = 0; index < source.length; index += 1) {
+    const code = source.charCodeAt(index)
+    const isLatin = (code >= 0x41 && code <= 0x5a) || (code >= 0x61 && code <= 0x7a) || (code >= 0x30 && code <= 0x39)
+    const isCjk = code >= 0x4e00 && code <= 0x9fff
+    if (isLatin) {
+      buffer += source[index]
+    } else if (isCjk) {
+      flush()
+      terms.push(source[index])
+      const previous = source[index - 1]
+      if (previous !== undefined && previous.charCodeAt(0) >= 0x4e00 && previous.charCodeAt(0) <= 0x9fff) {
+        terms.push(previous + source[index])
+      }
+    } else {
+      flush()
+    }
+  }
+  flush()
+  return terms
+}
+
+/**
+ * Build a BM25 index over documents.
+ * @param {Map<string, string>} documents - docKey → searchable text.
+ * @returns {Bm25Index} the built index.
+ */
+export function buildIndex(documents) {
+  /** @type {Map<string, Map<string, number>>} */
+  const termFreqs = new Map()
+  /** @type {Map<string, number>} */
+  const lengths = new Map()
+  /** @type {Map<string, number>} */
+  const docFreq = new Map()
+  for (const [key, text] of documents) {
+    const counts = new Map()
+    for (const term of tokenize(text)) counts.set(term, (counts.get(term) ?? 0) + 1)
+    termFreqs.set(key, counts)
+    lengths.set(key, [...counts.values()].reduce((sum, n) => sum + n, 0))
+    for (const term of counts.keys()) docFreq.set(term, (docFreq.get(term) ?? 0) + 1)
+  }
+  const avgLength = lengths.size === 0 ? 0 : [...lengths.values()].reduce((sum, n) => sum + n, 0) / lengths.size
+  return { termFreqs, lengths, docFreq, avgLength, total: lengths.size }
+}
+
+/**
+ * @typedef {object} Bm25Index
+ * @property {Map<string, Map<string, number>>} termFreqs
+ * @property {Map<string, number>} lengths
+ * @property {Map<string, number>} docFreq
+ * @property {number} avgLength
+ * @property {number} total
+ */
+
+/**
+ * Score one query against every indexed document.
+ * @param {Bm25Index} index - built index.
+ * @param {string} query - raw query text.
+ * @returns {Map<string, number>} docKey → BM25 score; only nonzero scores included.
+ */
+export function rank(index, query) {
+  const terms = tokenize(query)
+  const scores = new Map()
+  if (terms.length === 0 || index.total === 0) return scores
+  for (const [key, counts] of index.termFreqs) {
+    let score = 0
+    const length = index.lengths.get(key) ?? 0
+    const normalizer = K1 * (1 - B + B * (length / (index.avgLength || 1)))
+    for (const term of terms) {
+      const freq = counts.get(term)
+      if (freq === undefined) continue
+      const df = index.docFreq.get(term) ?? 0
+      const idf = Math.log(1 + (index.total - df + 0.5) / (df + 0.5))
+      score += idf * (freq * (K1 + 1)) / (freq + normalizer)
+    }
+    if (score > 0) scores.set(key, score)
+  }
+  return scores
+}

package/lib/scaffold.js

@@ -0,0 +1,235 @@
+/**
+ * Vault scaffolding: the mechanical half of the wiki skill's SCAFFOLD
+ * operation as one call. Creates the mode's folder structure, the core wiki
+ * files (index, log, hot cache, overview), per-folder sub-indexes, the mode's
+ * key seed pages, the vault AGENTS.md conventions file, and the raw-source
+ * manifest. Idempotent: existing files are kept and reported as skipped.
+ *
+ * @module dsh-plugin-wiki-tools/lib/scaffold
+ */
+
+import { mkdir, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { readFile } from 'node:fs/promises'
+import { today } from './vault.js'
+
+/**
+ * Folder sets per scaffold mode. `generic` matches the wiki_write routing
+ * (TYPE_FOLDERS); the six named modes follow the wiki skill's modes reference.
+ * `stubFolder` holds the mode's overview page; `stubs` are the key pages the
+ * mode's reference lists, each seeded into the folder named alongside it.
+ */
+export const SCAFFOLD_MODES = {
+  generic: {
+    label: 'Generic knowledge base',
+    folders: ['wiki/sources', 'wiki/entities', 'wiki/concepts', 'wiki/domains', 'wiki/questions', 'wiki/comparisons', 'wiki/meta'],
+    stubs: [],
+    typeFolders: {},
+  },
+  sitemap: {
+    label: 'Website / sitemap',
+    folders: ['wiki/pages', 'wiki/structure', 'wiki/audits', 'wiki/keywords', 'wiki/entities'],
+    stubs: [
+      { title: 'Site Overview', folder: 'wiki/structure', type: 'page' },
+      { title: 'Navigation Structure', folder: 'wiki/structure', type: 'page' },
+      { title: 'Content Gaps', folder: 'wiki/audits', type: 'page' },
+      { title: 'Redirect Map', folder: 'wiki/audits', type: 'page' },
+      { title: 'Keyword Clusters', folder: 'wiki/keywords', type: 'page' },
+    ],
+    typeFolders: { source: 'wiki/pages', entity: 'wiki/entities' },
+  },
+  repository: {
+    label: 'GitHub / repository',
+    folders: ['wiki/modules', 'wiki/components', 'wiki/decisions', 'wiki/dependencies', 'wiki/flows'],
+    stubs: [
+      { title: 'Architecture Overview', folder: 'wiki/modules', type: 'module' },
+      { title: 'Data Flow', folder: 'wiki/flows', type: 'flow' },
+      { title: 'Tech Stack', folder: 'wiki/dependencies', type: 'dependency' },
+      { title: 'Dependency Graph', folder: 'wiki/dependencies', type: 'dependency' },
+      { title: 'Key Decisions', folder: 'wiki/decisions', type: 'decision' },
+    ],
+    typeFolders: { source: 'wiki/modules', comparison: 'wiki/decisions' },
+  },
+  business: {
+    label: 'Business / project',
+    folders: ['wiki/stakeholders', 'wiki/decisions', 'wiki/deliverables', 'wiki/intel', 'wiki/comms'],
+    stubs: [
+      { title: 'Project Overview', folder: 'wiki/deliverables', type: 'deliverable' },
+      { title: 'Stakeholder Map', folder: 'wiki/stakeholders', type: 'stakeholder' },
+      { title: 'Decision Log', folder: 'wiki/decisions', type: 'decision' },
+      { title: 'Competitor Landscape', folder: 'wiki/intel', type: 'competitor' },
+    ],
+    typeFolders: { entity: 'wiki/stakeholders', source: 'wiki/comms', decision: 'wiki/decisions' },
+  },
+  personal: {
+    label: 'Personal / second brain',
+    folders: ['wiki/goals', 'wiki/learning', 'wiki/people', 'wiki/areas', 'wiki/resources'],
+    stubs: [
+      { title: 'North Star', folder: 'wiki/goals', type: 'goal' },
+      { title: 'Annual Goals', folder: 'wiki/goals', type: 'goal' },
+    ],
+    typeFolders: { concept: 'wiki/learning', domain: 'wiki/areas', entity: 'wiki/people', source: 'wiki/resources' },
+  },
+  research: {
+    label: 'Research',
+    folders: ['wiki/papers', 'wiki/concepts', 'wiki/entities', 'wiki/thesis', 'wiki/gaps'],
+    stubs: [
+      { title: 'Research Overview', folder: 'wiki/thesis', type: 'thesis' },
+      { title: 'Open Questions', folder: 'wiki/gaps', type: 'gap' },
+    ],
+    typeFolders: { source: 'wiki/papers', question: 'wiki/gaps', concept: 'wiki/concepts' },
+  },
+  book: {
+    label: 'Book / course',
+    folders: ['wiki/characters', 'wiki/themes', 'wiki/concepts', 'wiki/timeline', 'wiki/synthesis'],
+    stubs: [
+      { title: 'Book Overview', folder: 'wiki/timeline', type: 'chapter' },
+      { title: 'My Takeaways', folder: 'wiki/synthesis', type: 'synthesis' },
+    ],
+    typeFolders: { concept: 'wiki/concepts', question: 'wiki/synthesis' },
+  },
+}
+
+/**
+ * Scaffold one vault for a mode. Every artifact is written only when absent,
+ * so re-running after a partial scaffold or over an existing vault is safe.
+ * @param {string} root - absolute vault root.
+ * @param {object} input - scaffold options.
+ * @param {keyof typeof SCAFFOLD_MODES} input.mode - scaffold mode.
+ * @param {string} [input.purpose] - one-line vault purpose for overview and AGENTS.md.
+ * @returns {Promise<{ mode: string, created: string[], skipped: string[], suggestedTypeFolders: Record<string, string> }>}
+ */
+export async function scaffoldVault(root, { mode, purpose }) {
+  const spec = SCAFFOLD_MODES[mode]
+  if (spec === undefined) {
+    throw new Error(`wiki-tools: unknown scaffold mode "${mode}"; choose one of ${Object.keys(SCAFFOLD_MODES).join(', ')}`)
+  }
+  const date = today()
+  const created = []
+  const skipped = []
+  const writeIfAbsent = async (relPath, content) => {
+    const path = join(root, relPath)
+    if (await readFile(path, 'utf8').then(() => true, () => false)) {
+      skipped.push(relPath)
+      return
+    }
+    await mkdir(join(path, '..'), { recursive: true })
+    await writeFile(path, content, 'utf8')
+    created.push(relPath)
+  }
+
+  await writeIfAbsent('.raw/.manifest.json', '{"sources":{}}\n')
+  for (const folder of spec.folders) {
+    await writeIfAbsent(`${folder}/_index.md`, [
+      '---',
+      'type: meta',
+      `title: "${folder.split('/').pop()} Index"`,
+      `updated: ${date}`,
+      '---',
+      '',
+      `# ${folder.split('/').pop()}`,
+      '',
+    ].join('\n'))
+  }
+
+  await writeIfAbsent('wiki/index.md', indexTemplate(date))
+  await writeIfAbsent('wiki/log.md', `# Wiki Log\n`)
+  await writeIfAbsent('wiki/hot.md', [
+    '---',
+    'type: meta',
+    'title: "Hot Cache"',
+    `updated: ${date}`,
+    '---',
+    '',
+    '# Recent Context',
+    '',
+    `Scaffolded ${date}. ${purpose ?? spec.label}.`,
+    '',
+  ].join('\n'))
+  await writeIfAbsent('wiki/overview.md', [
+    '---',
+    'type: overview',
+    `title: "Overview"`,
+    `updated: ${date}`,
+    '---',
+    '',
+    '# Overview',
+    '',
+    purpose ?? spec.label,
+    '',
+  ].join('\n'))
+
+  for (const stub of spec.stubs) {
+    await writeIfAbsent(`${stub.folder}/${stub.title}.md`, [
+      '---',
+      `type: ${stub.type}`,
+      `title: "${stub.title}"`,
+      'status: seed',
+      `created: ${date}`,
+      `updated: ${date}`,
+      'tags:',
+      `  - ${stub.type}`,
+      '---',
+      '',
+      `# ${stub.title}`,
+      '',
+      `Seed page from ${mode} scaffold. Fill in.`,
+      '',
+    ].join('\n'))
+  }
+
+  await writeIfAbsent('AGENTS.md', agentsTemplate(mode, spec.label, purpose, date))
+
+  return { mode, created, skipped, suggestedTypeFolders: spec.typeFolders }
+}
+
+/**
+ * Master-index template with one empty section per generic type, in catalog
+ * order; named-mode vaults keep the same sections for their mapped types.
+ * @param {string} date - scaffold date.
+ * @returns {string} the index file content.
+ */
+function indexTemplate(date) {
+  const sections = ['Entities', 'Concepts', 'Sources', 'Questions']
+  return [
+    '---',
+    'type: meta',
+    'title: "Wiki Index"',
+    `updated: ${date}`,
+    '---',
+    '',
+    '# Wiki Index',
+    '',
+    ...sections.flatMap(section => [`## ${section}`, '']),
+  ].join('\n')
+}
+
+/**
+ * Vault conventions file: the rules every contributing agent follows.
+ * @param {string} mode - scaffold mode id.
+ * @param {string} label - human-readable mode label.
+ * @param {string | undefined} purpose - one-line vault purpose.
+ * @param {string} date - scaffold date.
+ * @returns {string} the AGENTS.md content.
+ */
+function agentsTemplate(mode, label, purpose, date) {
+  return `# Wiki Vault Conventions
+
+Mode: ${mode} (${label})
+Purpose: ${purpose ?? '(fill in)'}
+Created: ${date}
+
+## Rules
+
+- Every page uses flat YAML frontmatter: type, title, status, created, updated, tags at minimum.
+- status is one of seed | developing | mature | evergreen.
+- Wikilinks use [[Note Name]]; filenames are unique across the vault, no paths needed.
+- .raw/ holds immutable sources; never modify them.
+- wiki/index.md is the master catalog; every page is listed in its section.
+- wiki/log.md is append-only; new entries go at the TOP; never edit past entries.
+- wiki/hot.md is a ~500-word cache of recent context; overwrite it completely each update.
+- Prefer the wiki tools (wiki_query, wiki_write, wiki_rename, wiki_lint) over raw file edits;
+  they keep frontmatter, the index, the folder _index.md files, and the log consistent.
+- Contradictions between pages get > [!contradiction] callouts on both pages, never silent edits.
+`
+}

package/lib/search.js

@@ -9,6 +9,7 @@
 import { readFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import { buildAliasMap, collectMarkdown, isMachineryPage, resolveLinkTarget } from './vault.js'
+import { buildIndex, rank } from './bm25.js'
 
 /**
  * Answer the quick mode: the hot cache and master index verbatim. The caller
@@ -54,25 +55,30 @@ export async function searchVault(root, { query, limit = 10 }) {
       if (resolved !== undefined) inbound.get(resolved)?.push(page.name)
     }
   }
+  // BM25 ranks term overlap (latin words; CJK unigram+bigram); the substring
+  // bonuses below keep exact title/alias/tag phrases and partial words ahead,
+  // and a substring-only hit still surfaces when tokenization misses it.
+  const documents = new Map(searchable.map(page => [
+    page.name,
+    `${page.name} ${(page.aliases ?? []).join(' ')} ${tagsOf(page)} ${page.content}`,
+  ]))
+  const bm25Scores = rank(buildIndex(documents), query)
+
   const results = []
   let totalMatches = 0
   for (const page of searchable) {
-    const aliasText = (page.aliases ?? []).join(' ').toLowerCase()
-    const titleHits = (countOccurrences(page.name.toLowerCase(), needle)
-      + (aliasText.includes(needle) ? 1 : 0)) * 5
-    const tags = Array.isArray(page.fields?.tags) ? page.fields.tags.join(' ').toLowerCase() : ''
-    const tagHits = tags.includes(needle) ? 4 : 0
-    const headings = page.content.split('\n').filter(line => line.startsWith('#')).join('\n').toLowerCase()
-    const headingHits = countOccurrences(headings, needle) * 2
-    const body = page.content.toLowerCase()
-    const bodyHits = countOccurrences(body, needle)
-    const score = titleHits + tagHits + headingHits + bodyHits
-    if (score === 0) continue
+    const bm25 = bm25Scores.get(page.name) ?? 0
+    const titleHit = page.name.toLowerCase().includes(needle)
+      || (page.aliases ?? []).some(alias => alias.toLowerCase().includes(needle))
+    const tagHit = tagsOf(page).includes(needle)
+    const bodyHit = page.content.toLowerCase().includes(needle)
+    if (bm25 === 0 && !titleHit && !tagHit && !bodyHit) continue
     totalMatches += 1
+    const score = bm25 + (titleHit ? 5 : 0) + (tagHit ? 4 : 0) + (bodyHit ? 1 : 0)
     results.push({
       name: page.name,
       path: page.path,
-      score,
+      score: Math.round(score * 100) / 100,
       snippets: matchLines(page.content, needle).slice(0, 2),
       inbound: inbound.get(page.name) ?? [],
       outbound: new Set(page.links).size,
@@ -100,19 +106,12 @@ function matchLines(content, needle) {
   return lines
 }
 
+
 /**
- * Count substring occurrences.
- * @param {string} haystack - lowercased text.
- * @param {string} needle - lowercased substring.
- * @returns {number} occurrence count.
+ * A page's tags as one lowercase string for matching.
+ * @param {{ fields?: Record<string, unknown> }} page - collected page.
+ * @returns {string} space-joined tags.
  */
-function countOccurrences(haystack, needle) {
-  if (!haystack.includes(needle)) return 0
-  let count = 0
-  let index = haystack.indexOf(needle)
-  while (index >= 0) {
-    count += 1
-    index = haystack.indexOf(needle, index + needle.length)
-  }
-  return count
+function tagsOf(page) {
+  return Array.isArray(page.fields?.tags) ? page.fields.tags.join(' ').toLowerCase() : ''
 }

package/lib/vault.js

@@ -304,6 +304,41 @@ export class Vault {
     })
   }
 
+  /**
+   * Archive one raw source: move it from `.raw/` to `.archive/` (same
+   * subpath) and drop its manifest entry, the wiki skill's cold-source
+   * hygiene rule. Archived files leave the ingest set but stay on disk.
+   * @param {object} input - the archive request.
+   * @param {string} input.sourcePath - vault-relative `.raw/` path.
+   * @returns {Promise<{ archivedFrom: string, archivedTo: string }>}
+   */
+  async archiveSource({ sourcePath }) {
+    return await this.enqueue(join(this.root, '.archive'), async () => {
+      await this.assertRoot()
+      const absolute = isAbsolute(sourcePath) ? sourcePath : join(this.root, sourcePath)
+      const rel = relative(this.root, absolute).split(sep).join('/')
+      if (!rel.startsWith('.raw/')) {
+        throw new Error('wiki-tools: wiki_archive moves .raw/ sources only')
+      }
+      const raw = await readFile(absolute).catch(error => {
+        if (error.code === 'ENOENT') throw new Error(`wiki-tools: source ${sourcePath} not found under the vault`)
+        throw error
+      })
+      const destination = join(this.root, '.archive', rel.slice('.raw/'.length))
+      await mkdir(join(destination, '..'), { recursive: true })
+      await writeFile(destination, raw)
+      await rm(absolute)
+      const manifestPath = join(this.root, '.raw', '.manifest.json')
+      const manifest = await readJson(manifestPath, { sources: {} })
+      delete manifest.sources[rel]
+      await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8')
+      await this.prependLog(`## [${today()}] archive | ${rel}`, [
+        `- Archived: \`${rel}\` → \`.archive/${rel.slice('.raw/'.length)}\``,
+      ])
+      return { archivedFrom: rel, archivedTo: `.archive/${rel.slice('.raw/'.length)}` }
+    })
+  }
+
   /**
    * Remove one page's entry lines from the master index and its folder
    * `_index.md`, used when a rename replaces rather than refreshes.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-wiki-tools",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "Native DeepSeek Harness tools for an Obsidian wiki vault: wiki_query, wiki_write, and wiki_lint implement the mechanical core (path routing, delta tracking, index/log bookkeeping, health checks) of the wiki skill suite.",
   "license": "MIT",
   "type": "module",