@reventlessdev/reventless-spec 3.0.0-alpha.84 → 3.0.0-alpha.86

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.86 (2026-07-30)
+
+### Features
+
+* **spec,local:** resolve capability manifests beyond the example topology ([8bfadd5](https://github.com/ReventlessDev/reventless-core/commit/8bfadd5beef90c0c9f6f6f3fbb753c8b789469ed))
+* **spec:** semantic branded scalars — Email, Url, Phone, Percent, Color, Bytes, Duration ([2e64ff9](https://github.com/ReventlessDev/reventless-core/commit/2e64ff992e913c038a71659c731c25a104e3c5a9))
+
+
+# 3.0.0-alpha.85 (2026-07-30)
+
+### Features
+
+* **spec,core,local:** emit capabilities.json from the plugin build ([57a3276](https://github.com/ReventlessDev/reventless-core/commit/57a3276a6b02af93490a8b460e3aa158b7e0e0f8))
+* **spec,core:** derive the platform capability list — inference and generation (stage 3) ([8ab4d25](https://github.com/ReventlessDev/reventless-core/commit/8ab4d2504bd717487fbc87a0f5a053024c8258f9))
+
+
 # 3.0.0-alpha.84 (2026-07-29)
 
 ### Features

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@reventlessdev/reventless-spec",
-  "version": "3.0.0-alpha.84",
+  "version": "3.0.0-alpha.86",
   "description": "Specifications for Reventless",
   "license": "Apache-2.0",
   "bin": {
-    "generate-plugin": "./run-generator.mjs"
+    "generate-plugin": "./run-generator.mjs",
+    "generate-platform": "./run-platform-generator.mjs"
   },
   "jest": {
     "testMatch": [
@@ -18,7 +19,8 @@
   "dependencies": {
     "jsonschema2graphql": "1.1.1",
     "sury": "11.0.0-alpha.4",
-    "sury-ppx": "11.0.0-alpha.2"
+    "sury-ppx": "11.0.0-alpha.2",
+    "yaml": "^2.8.3"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/run-platform-generator.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "./src/generator/PlatformGenerator.res.mjs"

package/src/components/CapabilityManifest.res

@@ -0,0 +1,67 @@
+/**
+The per-plugin capability manifest — `capabilities.json`, written beside the
+generated `Plugin.res` by the plugin package's build.
+
+Each entry states one capability the plugin's fields declare they need, keyed
+by the store's qualified `{plugin}.{store}` identity, with the declaring
+`(component, field)` sites as provenance. The keys are taken verbatim from
+`pluginStructure.requiredStores` — the manifest is a rendering of the
+structure, never a second scan of the sources, so the two cannot spell one
+fact differently.
+
+The platform generator unions these files across a deployment's plugins and
+emits the platform's capability list from them.
+*/
+
+@schema
+type kind = ObjectStore
+
+/** The declaration site: the component's spec name and the field carrying the
+    `@storageRef` annotation. */
+@schema
+type provenance = {component: string, field: string}
+
+@schema
+type entry = {
+  kind: kind,
+  key: string,
+  declaredBy: array<provenance>,
+}
+
+@schema
+type t = {capabilities: array<entry>}
+
+/**
+Build the manifest from a plugin's structure.
+
+Keys iterate `requiredStores` itself, so a manifest's key set is byte-identical
+to what the deployed plugin reports at runtime — the contract the deploy-time
+coverage assertion checks against. A structure with no declarations yields an
+empty `capabilities` list, not an absent file: "declares nothing" is a
+statement, and the generator reading the manifests must be able to tell it
+apart from "was never built".
+*/
+let fromStructure = (structure: Plugin.pluginStructure): t => {
+  let declarations = structure.requiredStoreDeclarations->Option.getOr([])
+  {
+    capabilities: structure.requiredStores
+    ->Option.getOr([])
+    ->Array.map(key => {
+      kind: ObjectStore,
+      key,
+      declaredBy: declarations->Array.filterMap(d =>
+        d.store == key ? Some({component: d.component, field: d.field}) : None
+      ),
+    }),
+  }
+}
+
+/** Deterministic rendering: 2-space indent, trailing newline. Rebuilding with
+    no source change must produce a byte-identical file, so the committed
+    manifest never churns. */
+let render = (manifest: t): string =>
+  JSON.stringify(manifest->S.reverseConvertToJsonOrThrow(schema), ~space=2) ++ "\n"
+
+/** One call for the emit CLI: structure in, `capabilities.json` content out. */
+let renderForStructure = (structure: Plugin.pluginStructure): string =>
+  structure->fromStructure->render

package/src/components/CapabilityManifest.res.mjs

@@ -0,0 +1,59 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+let kindSchema = S.literal("ObjectStore");
+
+let provenanceSchema = S.schema(s => ({
+  component: s.m(S.string),
+  field: s.m(S.string)
+}));
+
+let entrySchema = S.schema(s => ({
+  kind: s.m(kindSchema),
+  key: s.m(S.string),
+  declaredBy: s.m(S.array(provenanceSchema))
+}));
+
+let schema = S.schema(s => ({
+  capabilities: s.m(S.array(entrySchema))
+}));
+
+function fromStructure(structure) {
+  let declarations = Stdlib_Option.getOr(structure.requiredStoreDeclarations, []);
+  return {
+    capabilities: Stdlib_Option.getOr(structure.requiredStores, []).map(key => ({
+      kind: "ObjectStore",
+      key: key,
+      declaredBy: Stdlib_Array.filterMap(declarations, d => {
+        if (d.store === key) {
+          return {
+            component: d.component,
+            field: d.field
+          };
+        }
+      })
+    }))
+  };
+}
+
+function render(manifest) {
+  return JSON.stringify(S.reverseConvertToJsonOrThrow(manifest, schema), undefined, 2) + "\n";
+}
+
+function renderForStructure(structure) {
+  return render(fromStructure(structure));
+}
+
+export {
+  kindSchema,
+  provenanceSchema,
+  entrySchema,
+  schema,
+  fromStructure,
+  render,
+  renderForStructure,
+}
+/* kindSchema Not a pure module */

package/src/components/Plugin.res

@@ -379,6 +379,26 @@ type extensionPointDef = {
 // jsonableValidation inside the pluginStructure union variant payload.
 let extensionPointDefArrayOptionSchema = _jsNullable(S.array(extensionPointDefSchema), ())
 
+/**
+One field's store requirement, with its provenance.
+
+`store` is the same qualified `{plugin}.{store}` string `requiredStores`
+carries; `component` and `field` name the declaration site. The site matters
+because a requirement only ever changes by editing a field — when a rename
+removes a store from the manifest, the diff has to say which field caused it.
+*/
+@schema
+type requiredStoreDeclaration = {
+  store: string,
+  component: string,
+  field: string,
+}
+
+let requiredStoreDeclarationArrayOptionSchema = _jsNullable(
+  S.array(requiredStoreDeclarationSchema),
+  (),
+)
+
 @schema
 type pluginStructure = {
   readModels: array<queryableDef>,
@@ -409,6 +429,14 @@ type pluginStructure = {
    existed still decode (absent → None, read as []).
    */
   requiredStores: @s.matches(stringArrayOptionSchema) option<array<string>>,
+  /**
+   Provenance for `requiredStores`: one entry per declaring `(component, field)`
+   site, with `store` matching the qualified key above. `requiredStores` is
+   derived from this list, so the two cannot disagree. Optional and js_nullable
+   for the same reason as `extensionPoints`.
+   */
+  requiredStoreDeclarations: @s.matches(requiredStoreDeclarationArrayOptionSchema)
+  option<array<requiredStoreDeclaration>>,
 }
 
 let pluginStructureOptionSchema = _jsNullable(pluginStructureSchema, ())

package/src/components/Plugin.res.mjs

@@ -178,6 +178,14 @@ let extensionPointDefSchema = S.schema(s => ({
 
 let extensionPointDefArrayOptionSchema = SuryResMjs.js_nullable(S.array(extensionPointDefSchema));
 
+let requiredStoreDeclarationSchema = S.schema(s => ({
+  store: s.m(S.string),
+  component: s.m(S.string),
+  field: s.m(S.string)
+}));
+
+let requiredStoreDeclarationArrayOptionSchema = SuryResMjs.js_nullable(S.array(requiredStoreDeclarationSchema));
+
 let pluginStructureSchema = S.schema(s => ({
   readModels: s.m(S.array(queryableDefSchema)),
   stateViewSlices: s.m(S.array(queryableDefSchema)),
@@ -188,7 +196,8 @@ let pluginStructureSchema = S.schema(s => ({
   inboundTranslationSlices: s.m(S.array(inboundTranslationSliceDefSchema)),
   extensions: s.m(S.array(extensionDefSchema)),
   extensionPoints: s.m(extensionPointDefArrayOptionSchema),
-  requiredStores: s.m(stringArrayOptionSchema)
+  requiredStores: s.m(stringArrayOptionSchema),
+  requiredStoreDeclarations: s.m(requiredStoreDeclarationArrayOptionSchema)
 }));
 
 let pluginStructureOptionSchema = SuryResMjs.js_nullable(pluginStructureSchema);
@@ -244,6 +253,8 @@ export {
   extensionDefSchema,
   extensionPointDefSchema,
   extensionPointDefArrayOptionSchema,
+  requiredStoreDeclarationSchema,
+  requiredStoreDeclarationArrayOptionSchema,
   pluginStructureSchema,
   pluginStructureOptionSchema,
   pluginDefinitionSchema,

package/src/generator/PlatformCodegen.res

@@ -0,0 +1,139 @@
+// Pure rendering for the platform generator: union the plugins' capability
+// manifests and emit the committed `PlatformCapabilities.res`.
+//
+// Only the derived list is generated — the platform root stays hand-written
+// and reads `PlatformCapabilities.capabilities`. That keeps a requirement
+// change small and entirely about capabilities in review, and it keeps the
+// generator out of the business of expressing everything a real root does
+// (bootstrap calls, capability handles, stack references).
+//
+// I/O-free so the exact bytes are testable; `PlatformGenerator` owns the file
+// system.
+
+/** One plugin's manifest, tagged with the name `deploy-manifest.yaml` lists it
+    under — the name provenance comments cite. */
+type pluginManifest = {
+  pluginName: string,
+  manifest: CapabilityManifest.t,
+}
+
+/** One declaring site, keeping which plugin's manifest carried it. */
+type provenance = {
+  pluginName: string,
+  component: string,
+  field: string,
+}
+
+/** One capability the platform must provision: the qualified `{plugin}.{store}`
+    key with every declaring site across every plugin. Identity is the key —
+    many fields, in several plugins, legitimately name one store. */
+type unionEntry = {
+  kind: CapabilityManifest.kind,
+  key: string,
+  declaredBy: array<provenance>,
+}
+
+/** Union the manifests: entries with one key collapse to one capability, their
+    provenance concatenated in manifest order. Sorted by key so the rendered
+    file is deterministic. */
+let union = (manifests: array<pluginManifest>): array<unionEntry> => {
+  let byKey: dict<unionEntry> = Dict.make()
+  manifests->Array.forEach(({pluginName, manifest}) =>
+    manifest.capabilities->Array.forEach(entry => {
+      let sites =
+        entry.declaredBy->Array.map(site => {
+          pluginName,
+          component: site.component,
+          field: site.field,
+        })
+      switch byKey->Dict.get(entry.key) {
+      | Some(existing) =>
+        byKey->Dict.set(entry.key, {...existing, declaredBy: existing.declaredBy->Array.concat(sites)})
+      | None => byKey->Dict.set(entry.key, {kind: entry.kind, key: entry.key, declaredBy: sites})
+      }
+    })
+  )
+  byKey
+  ->Dict.valuesToArray
+  ->Array.toSorted((a, b) => String.compare(a.key, b.key))
+}
+
+let quote = (s: string): string => s->JSON.Encode.string->JSON.stringify
+
+// A key is `{plugin}.{store}` by construction (`Plugin_Structure` qualifies
+// every declaration). The split is at the first dot: the plugin's registered
+// name cannot contain one, the store name could in principle.
+let splitKey = (key: string): option<(string, string)> =>
+  key
+  ->String.indexOfOpt(".")
+  ->Option.map(i => (
+    key->String.slice(~start=0, ~end=i),
+    key->String.slice(~start=i + 1),
+  ))
+
+// The provenance comment quotes the annotation as its author wrote it: a store
+// declared by its own plugin is unqualified, a foreign store keeps the
+// qualified form. The manifest carries only the deploy-manifest plugin name
+// (lowercase by convention) while the key carries the registered name, so the
+// comparison is case-insensitive — and it only shapes a comment.
+let annotationStore = (~pluginName, ~key): string =>
+  switch splitKey(key) {
+  | Some((keyPlugin, store)) if keyPlugin->String.toLowerCase == pluginName->String.toLowerCase => store
+  | _ => key
+  }
+
+let renderEntry = (entry: unionEntry): result<array<string>, string> =>
+  switch splitKey(entry.key) {
+  | None =>
+    Error(
+      `malformed capability key ${quote(entry.key)} — expected "{plugin}.{store}" (is the plugin's capabilities.json hand-edited?)`,
+    )
+  | Some((plugin, store)) => {
+      let comments =
+        entry.declaredBy->Array.map(site =>
+          `  // ${site.pluginName}: ${site.component}.${site.field} @storageRef(${quote(
+              annotationStore(~pluginName=site.pluginName, ~key=entry.key),
+            )})`
+        )
+      let line = switch entry.kind {
+      | ObjectStore => `  ObjectStore({plugin: ${quote(plugin)}, store: ${quote(store)}}),`
+      }
+      Ok(comments->Array.concat([line]))
+    }
+  }
+
+let header = [
+  "// AUTO-GENERATED — do not edit. Run `pnpm run generate:platform` to update.",
+  "//",
+  "// The platform's capability list, unioned from the committed",
+  "// `capabilities.json` manifests of the plugins deploy-manifest.yaml names.",
+  "// Each entry keeps its declaring fields as provenance, so when a capability",
+  "// disappears from this list, the diff says which field's change removed it.",
+  "",
+]
+
+/** Render the complete `PlatformCapabilities.res`. Deterministic and
+    newline-terminated: regenerating with no manifest change is byte-identical,
+    so the committed file never churns. */
+let render = (manifests: array<pluginManifest>): result<string, string> => {
+  let entries = union(manifests)
+  let rendered = entries->Array.map(renderEntry)
+  switch rendered->Array.findMap(r =>
+    switch r {
+    | Error(e) => Some(e)
+    | Ok(_) => None
+    }
+  ) {
+  | Some(e) => Error(e)
+  | None => {
+      let body = if entries->Array.length == 0 {
+        ["let capabilities: array<ReventlessInfra.Platform.capability> = []"]
+      } else {
+        ["let capabilities: array<ReventlessInfra.Platform.capability> = ["]
+        ->Array.concat(rendered->Array.flatMap(r => r->Result.getOr([])))
+        ->Array.concat(["]"])
+      }
+      Ok(header->Array.concat(body)->Array.join("\n") ++ "\n")
+    }
+  }
+}

package/src/generator/PlatformCodegen.res.mjs

@@ -0,0 +1,116 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as Stdlib_String from "@rescript/runtime/lib/es6/Stdlib_String.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+
+function union(manifests) {
+  let byKey = {};
+  manifests.forEach(param => {
+    let pluginName = param.pluginName;
+    param.manifest.capabilities.forEach(entry => {
+      let sites = entry.declaredBy.map(site => ({
+        pluginName: pluginName,
+        component: site.component,
+        field: site.field
+      }));
+      let existing = byKey[entry.key];
+      if (existing !== undefined) {
+        byKey[entry.key] = {
+          kind: existing.kind,
+          key: existing.key,
+          declaredBy: existing.declaredBy.concat(sites)
+        };
+      } else {
+        byKey[entry.key] = {
+          kind: entry.kind,
+          key: entry.key,
+          declaredBy: sites
+        };
+      }
+    });
+  });
+  return Object.values(byKey).toSorted((a, b) => Primitive_string.compare(a.key, b.key));
+}
+
+function quote(s) {
+  return JSON.stringify(s);
+}
+
+function splitKey(key) {
+  return Stdlib_Option.map(Stdlib_String.indexOfOpt(key, "."), i => [
+    key.slice(0, i),
+    key.slice(i + 1 | 0)
+  ]);
+}
+
+function annotationStore(pluginName, key) {
+  let match = splitKey(key);
+  if (match !== undefined && match[0].toLowerCase() === pluginName.toLowerCase()) {
+    return match[1];
+  } else {
+    return key;
+  }
+}
+
+function renderEntry(entry) {
+  let match = splitKey(entry.key);
+  if (match === undefined) {
+    return {
+      TAG: "Error",
+      _0: `malformed capability key ` + JSON.stringify(entry.key) + ` — expected "{plugin}.{store}" (is the plugin's capabilities.json hand-edited?)`
+    };
+  }
+  let comments = entry.declaredBy.map(site => `  // ` + site.pluginName + `: ` + site.component + `.` + site.field + ` @storageRef(` + JSON.stringify(annotationStore(site.pluginName, entry.key)) + `)`);
+  let line = `  ObjectStore({plugin: ` + JSON.stringify(match[0]) + `, store: ` + JSON.stringify(match[1]) + `}),`;
+  return {
+    TAG: "Ok",
+    _0: comments.concat([line])
+  };
+}
+
+let header = [
+  "// AUTO-GENERATED — do not edit. Run `pnpm run generate:platform` to update.",
+  "//",
+  "// The platform's capability list, unioned from the committed",
+  "// `capabilities.json` manifests of the plugins deploy-manifest.yaml names.",
+  "// Each entry keeps its declaring fields as provenance, so when a capability",
+  "// disappears from this list, the diff says which field's change removed it.",
+  ""
+];
+
+function render(manifests) {
+  let entries = union(manifests);
+  let rendered = entries.map(renderEntry);
+  let e = Stdlib_Array.findMap(rendered, r => {
+    if (r.TAG === "Ok") {
+      return;
+    } else {
+      return r._0;
+    }
+  });
+  if (e !== undefined) {
+    return {
+      TAG: "Error",
+      _0: e
+    };
+  }
+  let body = entries.length === 0 ? ["let capabilities: array<ReventlessInfra.Platform.capability> = []"] : ["let capabilities: array<ReventlessInfra.Platform.capability> = ["].concat(rendered.flatMap(r => Stdlib_Result.getOr(r, []))).concat(["]"]);
+  return {
+    TAG: "Ok",
+    _0: header.concat(body).join("\n") + "\n"
+  };
+}
+
+export {
+  union,
+  quote,
+  splitKey,
+  annotationStore,
+  renderEntry,
+  header,
+  render,
+}
+/* No side effect */

package/src/generator/PlatformGenerator.res

@@ -0,0 +1,127 @@
+// Entry point for the platform generator.
+// Usage: generate-platform <deploy-manifest.yaml>
+//
+// Reads the deploy manifest for the plugin list, unions the plugins' committed
+// `capabilities.json` manifests, and writes the platform's committed
+// `PlatformCapabilities.res` (see PlatformCodegen). The platform root stays
+// hand-written and reads `PlatformCapabilities.capabilities`.
+//
+// A deploy manifest enumerates *deployables*, not plugins, and a plugin's
+// manifest can sit in any of three places. `PlatformManifests` owns both facts —
+// its head comment states the resolution order and why each arm exists; add a
+// fourth arm there, not here.
+
+@val external processExit: int => unit = "process.exit"
+@module("yaml") external parseYaml: string => JSON.t = "parse"
+
+let fail = (message: string) => {
+  Console.error("generate-platform: " ++ message)
+  processExit(1)
+}
+
+let asObject = (json: JSON.t): option<dict<JSON.t>> => json->JSON.Decode.object
+let stringAt = (obj: dict<JSON.t>, field: string): option<string> =>
+  obj->Dict.get(field)->Option.flatMap(JSON.Decode.string)
+
+let () = {
+  let manifestArg = Generator_Node.argv->Array.get(2)->Option.getOr("")
+  if manifestArg == "" {
+    Console.error("Usage: generate-platform <deploy-manifest.yaml>")
+    processExit(1)
+  } else {
+    let manifestPath = Generator_Node.resolve([manifestArg])
+    if !Generator_Node.existsSync(manifestPath) {
+      fail(`${manifestPath} not found`)
+    }
+    let manifestDir = Generator_Node.dirname(manifestPath)
+    let deployManifest = try Generator_Node.readFileSync(manifestPath)->parseYaml catch {
+    | _ => {
+        fail(`could not parse ${manifestPath} as YAML`)
+        JSON.Null
+      }
+    }
+
+    let platformPath =
+      deployManifest
+      ->asObject
+      ->Option.flatMap(m => m->Dict.get("platform"))
+      ->Option.flatMap(asObject)
+      ->Option.flatMap(p => p->stringAt("path"))
+    let plugins =
+      deployManifest
+      ->asObject
+      ->Option.flatMap(m => m->Dict.get("plugins"))
+      ->Option.flatMap(JSON.Decode.array)
+      ->Option.map(entries =>
+        entries->Array.filterMap(entry => {
+          let obj = entry->asObject
+          switch (
+            obj->Option.flatMap(o => o->stringAt("name")),
+            obj->Option.flatMap(o => o->stringAt("path")),
+          ) {
+          | (Some(name), Some(path)) => Some((name, path))
+          | _ => None
+          }
+        })
+      )
+
+    switch (platformPath, plugins) {
+    | (Some(platformPath), Some(plugins)) => {
+        let pluginManifests = plugins->Array.flatMap(((pluginName, pluginPath)) => {
+          let pluginDir = Generator_Node.resolve([manifestDir, pluginPath])
+          if !Generator_Node.existsSync(pluginDir) {
+            fail(`plugin "${pluginName}" points at ${pluginDir}, which does not exist`)
+          }
+          switch PlatformManifests.resolve(~pluginDir) {
+          // A stack whose package graph holds no plugin composition — an
+          // SdkService, an SPA, a standalone Lambda — has no capabilities to
+          // contribute, which is not an error. Said out loud so a plugin
+          // skipped by mistake is visible in the generator's output.
+          | NotAPlugin => {
+              Console.log(`Skipped: ${pluginName} (${pluginDir}) — no plugin composition`)
+              []
+            }
+          | Unbuilt({evidence, expected}) => {
+              fail(
+                `no capabilities.json found for plugin "${pluginName}" (${pluginDir}) — ` ++
+                `build the plugin first; its build emits src/capabilities.json beside Plugin.res ` ++
+                `(${evidence}; expected ${expected})`,
+              )
+              []
+            }
+          | Manifests(manifests) =>
+            manifests->Array.map(({path, via}) => {
+              Console.log(
+                `Read: ${pluginName} — ${path} (via ${PlatformManifests.describeVia(via)})`,
+              )
+              let manifest = try Generator_Node.readFileSync(path)
+              ->JSON.parseOrThrow
+              ->S.parseOrThrow(CapabilityManifest.schema) catch {
+              | _ => {
+                  fail(`could not parse ${path} as a capability manifest`)
+                  ({capabilities: []}: CapabilityManifest.t)
+                }
+              }
+              ({pluginName, manifest}: PlatformCodegen.pluginManifest)
+            })
+          }
+        })
+
+        switch PlatformCodegen.render(pluginManifests) {
+        | Error(message) => fail(message)
+        | Ok(source) => {
+            let outputPath = Generator_Node.resolve([
+              manifestDir,
+              platformPath,
+              "src",
+              "PlatformCapabilities.res",
+            ])
+            Generator_Node.writeFileSync(outputPath, source)
+            Console.log("Generated: " ++ outputPath)
+          }
+        }
+      }
+    | _ => fail(`${manifestPath} needs a \`platform.path\` and a \`plugins\` list with name + path`)
+    }
+  }
+}