lecodes-cli 2.4.1 → 2.4.3

package/src/plugin/emitWeb.ts

@@ -358,18 +358,27 @@ export interface PluginGL {
   /** The pose of the scene's camera (its world matrix). */
   setCameraMatrix(scene: number, m16: ArrayLike<number>): void
   /** A projection the half computes (column-major, OpenGL clip conventions), with the near / far it
-   *  was built with, in place of the scene's fov projection. */
+   *  was built with, in place of the scene's fov projection: drawn as it is — an off-centre one (a
+   *  camera's intrinsics) too. Made for one view: a change of \`viewport\` wants a new one. */
   setProjection(scene: number, m16: ArrayLike<number>, near: number, far: number): void
   /** Back to the scene's own (fov) projection. */
   clearProjection(scene: number): void
-  /** The scene's background: a playing video behind the scene, through \`uv\` — the affine map from
-   *  the viewport's normalized coordinates (0,0 top-left) to the video's, row-major
-   *  [a, b, tx, c, d, ty] (identity by default). null = none. */
-  setBackground(scene: number, video: HTMLVideoElement | null, uv?: ArrayLike<number>): void
-  /** The web has no external textures: a video is handed to setBackground as it is. Always null. */
+  /** The scene's background, behind the scene: a playing video (a camera's stream), or a canvas the
+   *  half (or an engine it runs) draws the camera's picture on; null = none. \`uv\` = the affine map
+   *  from the viewport's normalized coordinates (0,0 top-left) to the picture's, row-major
+   *  [a, b, tx, c, d, ty] (identity by default). Web Lite shows the element itself: moved under the
+   *  scene's canvas (its inline style replaced: absolute, the scene's box filled, \`object-fit: cover\`
+   *  — \`uv\` is not read; a canvas sized to \`viewport\` × devicePixelRatio is shown 1:1), taken out of
+   *  the page when it is replaced or cleared. The web player (a preview) shows a video only. */
+  setBackground(scene: number, source: HTMLVideoElement | HTMLCanvasElement | null, uv?: ArrayLike<number>): void
+  /** The web has no external textures: a video or a canvas is handed to setBackground as it is.
+   *  Always null. */
   createExternalTexture(): null
-  /** \`body\` before each frame (the page's animation frame), until the returned function is called —
-   *  or the world swap. */
+  /** \`body\` before each frame of the 3D engine, until the returned function is called — or the
+   *  world swap: in the host's own animation frame, before the tick and the render, so what a body
+   *  sets (a pose, a projection) is that frame's picture. A requestAnimationFrame callback of the
+   *  half's own is a frame late unless the browser runs it before the host's (callbacks run in the
+   *  order they were asked for). Web Lite runs the bodies while a scene is on show. */
   onFrame(body: () => void): () => void
   /** The composite of the scene's next frame — the 3D picture, not the UI over it: RGBA8, top row
    *  first, width, height; null (0 × 0) when the scene is not the one presented. */

package/src/plugin/firstParty.ts

@@ -0,0 +1,30 @@
+// The first-party plugins as the SDK carries them: `plugins/gen/<id>/` of its source tree — the
+// contract.d.ts and the app's wrapper (sdk/), copies of the plugin repo's (core's
+// scripts/vendor-plugins.ts). A project's HALF FOLDER (`implements` in its manifest) implements one
+// of these contracts: the one of the SDK this CLI compiles with, so the glue `lecodes plugin gen`
+// writes for the half and the wrapper in the bundle are of one contract.
+
+import { existsSync, readFileSync, readdirSync } from "node:fs"
+import { join } from "node:path"
+import { sdkSourceDir } from "../compile/projectCompile"
+
+const ID = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/
+
+/** The SDK's copy of a first-party plugin's contract, or null when the SDK carries no such plugin. */
+export const firstPartyContractFile = (id: string): string | null => {
+  if (!sdkSourceDir || !ID.test(id)) return null
+  const file = join(sdkSourceDir, "plugins", "gen", id, "contract.d.ts")
+  return existsSync(file) ? file : null
+}
+
+/** The first-party plugins the SDK carries, by id. */
+export const firstPartyIds = (): string[] => {
+  if (!sdkSourceDir) return []
+  const gen = join(sdkSourceDir, "plugins", "gen")
+  return existsSync(gen) ? readdirSync(gen).filter((id) => existsSync(join(gen, id, "contract.d.ts"))).sort() : []
+}
+
+/** A copy's text as the plugin wrote it: the vendoring points the import of the SDK at its own file
+ *  (`../../../plugin`), a contract reads `lecodes-sdk/plugin` and nothing else. */
+export const firstPartyContractText = (file: string): string =>
+  readFileSync(file, "utf8").replace(/from "(?:\.\.\/)+plugin"/g, `from "lecodes-sdk/plugin"`)

package/src/plugin/generate.ts

@@ -16,7 +16,8 @@ import { EmitError, emitSdk } from "./emitSdk"
 import { emitSwift } from "./emitSwift"
 import { emitWeb } from "./emitWeb"
 import { lower } from "./lower"
-import { MANIFEST_FILE, ManifestError, readManifestIfAny, type PluginManifest } from "./manifest"
+import { CONTRACT_FILE, MANIFEST_FILE, ManifestError, readManifestIfAny, type PluginManifest } from "./manifest"
+import { firstPartyContractFile, firstPartyContractText } from "./firstParty"
 import { missingDeclarations, usesFeatures, usesPermissions, type PermissionKind } from "./permissions"
 import { DEFAULT_SDK_PATH, PACKAGE_FILE, PackageError, emitPackageSwift } from "./emitPackage"
 
@@ -24,19 +25,31 @@ import { DEFAULT_SDK_PATH, PACKAGE_FILE, PackageError, emitPackageSwift } from "
 // compared and pasted; `\` is Windows' own).
 const shown = (from: string, to: string): string => relative(from, to).split(sep).join("/")
 
-export const CONTRACT_FILE = "contract.d.ts"
+export { CONTRACT_FILE }
 
 export type PluginDir = { id: string, dir: string }
 
-/** The plugins under `path`: itself when it holds a contract, else every `plugins/<id>/` that does. */
+/** The first-party plugin a folder's manifest says it implements (a project's half folder), or null.
+ *  Read loosely: what the manifest holds is readManifest's to say. */
+const implementsOf = (dir: string): string | null => {
+  try {
+    const raw = JSON.parse(readFileSync(join(dir, MANIFEST_FILE), "utf8").replace(/^/, "")) as { implements?: unknown }
+    return typeof raw.implements === "string" ? raw.implements : null
+  } catch { return null }
+}
+
+/** A plugin's folder: one with its contract, or a half folder that implements a first-party one's. */
+const isPluginDir = (dir: string): boolean => existsSync(join(dir, CONTRACT_FILE)) || implementsOf(dir) !== null
+
+/** The plugins under `path`: itself when it is one, else every `plugins/<id>/` that is. */
 export const findPlugins = (path: string): PluginDir[] => {
   const root = resolve(path)
-  if (existsSync(join(root, CONTRACT_FILE))) return [{ id: basename(root), dir: root }]
+  if (isPluginDir(root)) return [{ id: basename(root), dir: root }]
   const holder = join(root, "plugins")
   if (!existsSync(holder)) return []
   return readdirSync(holder).sort()
     .map(id => ({ id, dir: join(holder, id) }))
-    .filter(p => statSync(p.dir).isDirectory() && existsSync(join(p.dir, CONTRACT_FILE)))
+    .filter(p => statSync(p.dir).isDirectory() && isPluginDir(p.dir))
 }
 
 /** The CLI carries no TypeScript: a contract is read with the one its author has — the plugin's own
@@ -54,34 +67,39 @@ export const loadTypescript = (dir: string): typeof tsModule => {
 
 export type Generated = { file: string, text: string }
 
-/** Everything one plugin's contract generates, as `path → text`. Throws ContractError / EmitError. */
+/** Everything one plugin's contract generates, as `path → text`. Throws ContractError / EmitError /
+ *  ManifestError. A half folder (`implements`) is generated from the contract of the plugin it
+ *  implements, the SDK's copy (firstParty.ts), and under that plugin's id: `web/ar.gen.ts` registers
+ *  the service "ar"; it has no sdk/ — the app's side is the SDK's wrapper. */
 export const generatePlugin = (ts: typeof tsModule, plugin: PluginDir): { contract: Contract, manifest: PluginManifest | null, files: Generated[] } => {
-  const file = join(plugin.dir, CONTRACT_FILE)
-  const contract = readContract(ts, file, readFileSync(file, "utf8"))
   // The manifest is held to the folders the plugin has: a half the manifest does not name is built
   // into no host.
   const manifest = readManifestIfAny(plugin.dir, plugin.id)
+  const implemented = manifest?.implements
+  const file = implemented ? firstPartyContractFile(implemented)! : join(plugin.dir, CONTRACT_FILE)
+  const contract = readContract(ts, file, implemented ? firstPartyContractText(file) : readFileSync(file, "utf8"))
   checkPermissions(plugin, contract, manifest)
-  const handWritten = existsSync(join(plugin.dir, "sdk", `${plugin.id}.ts`))
+  const id = implemented ?? plugin.id
+  const handWritten = existsSync(join(plugin.dir, "sdk", `${id}.ts`))
   const single = contract.channels.length === 1
-  const files: Generated[] = contract.channels.map(channel => ({
+  const files: Generated[] = implemented ? [] : contract.channels.map(channel => ({
     // One channel is the rule; a contract with several names each file after its channel.
-    file: join(plugin.dir, "sdk", single ? `${plugin.id}.gen.ts` : `${plugin.id}.${channel.iface}.gen.ts`),
-    text: emitSdk(contract, channel, { id: plugin.id, handWritten }),
+    file: join(plugin.dir, "sdk", single ? `${id}.gen.ts` : `${id}.${channel.iface}.gen.ts`),
+    text: emitSdk(contract, channel, { id, handWritten }),
   }))
   // A platform's file is generated where its FOLDER exists: the plugin says which platforms it has
   // by having them.
   if (existsSync(join(plugin.dir, "ios"))) {
     const name = single ? contract.channels[0]!.iface : contract.channels[0]!.iface + "Plugin"
-    files.push({ file: join(plugin.dir, "ios", `${name}.gen.swift`), text: emitSwift(lower(contract), { id: plugin.id }) })
+    files.push({ file: join(plugin.dir, "ios", `${name}.gen.swift`), text: emitSwift(lower(contract), { id }) })
   }
   if (existsSync(join(plugin.dir, "android"))) {
     const name = single ? contract.channels[0]!.iface : contract.channels[0]!.iface + "Plugin"
-    const pkg = kotlinPackage(join(plugin.dir, "android"))
-    files.push({ file: join(pkg.dir, `${name}.gen.kt`), text: emitKotlin(lower(contract), { id: plugin.id, package: pkg.name }) })
+    const pkg = kotlinPackage(join(plugin.dir, "android"), manifest?.android?.register)
+    files.push({ file: join(pkg.dir, `${name}.gen.kt`), text: emitKotlin(lower(contract), { id, package: pkg.name }) })
   }
   if (existsSync(join(plugin.dir, "web"))) {
-    files.push({ file: join(plugin.dir, "web", `${plugin.id}.gen.ts`), text: emitWeb(lower(contract), { id: plugin.id }) })
+    files.push({ file: join(plugin.dir, "web", `${id}.gen.ts`), text: emitWeb(lower(contract), { id }) })
     const foreign = hostImports(join(plugin.dir, "web"))
     if (foreign.length) throw new EmitError(`web/ imports the host — a web half depends on its generated file, the document it is handed and the browser:\n${foreign.map(f => `  ${f}`).join("\n")}`)
   }
@@ -131,9 +149,17 @@ export const hostImports = (web: string): string[] => {
 
 /** Where a plugin's Kotlin lives: `android/` is laid out as a Gradle module (its manifest and
  *  resources travel with the sources), and the generated file is a file of the plugin's PACKAGE —
- *  the one folder under `src/main/java` that the path narrows down to. */
-export const kotlinPackage = (android: string): { dir: string, name: string } => {
+ *  the package of the type that registers the half (the manifest's `android.register`, which is
+ *  also the module's namespace), when its folder is there; else the one folder under
+ *  `src/main/java` that the path narrows down to (a plugin with no manifest yet). A half may hold
+ *  other packages beside its own (a vendored library's JNI class): they do not move the file. */
+export const kotlinPackage = (android: string, register?: string): { dir: string, name: string } => {
   const root = join(android, "src", "main", "java")
+  if (register) {
+    const name = register.split(".").slice(0, -1).join(".")
+    const dir = join(root, ...name.split("."))
+    if (name && existsSync(dir)) return { dir, name }
+  }
   let dir = root
   while (existsSync(dir)) {
     const entries = readdirSync(dir).filter(e => !e.startsWith("."))
@@ -164,7 +190,8 @@ export const repoSdkPath = (root: string): string => {
 }
 
 export type GenReport = {
-  plugins: { id: string, contract: Contract, written: string[], stale: string[], fresh: string[] }[]
+  /** `implements`: a half folder's first-party plugin, whose contract it was generated from. */
+  plugins: { id: string, implements?: string, contract: Contract, written: string[], stale: string[], fresh: string[] }[]
   /** The repo's own files (its Package.swift), when the path is a repo of plugins. */
   repo: { written: string[], stale: string[], fresh: string[] }
   /** Contracts that did not read or emit, as printable text. */
@@ -175,7 +202,7 @@ export type GenReport = {
  *  to `path`. A failed contract does not stop the others. */
 export const generate = (path: string, opts: { check?: boolean } = {}): GenReport => {
   const plugins = findPlugins(path)
-  if (plugins.length === 0) throw new CliError(`No plugin under ${resolve(path)}: a plugin is a directory with a ${CONTRACT_FILE} (one, or plugins/<id>/ of a repo).`)
+  if (plugins.length === 0) throw new CliError(`No plugin under ${resolve(path)}: a plugin is a directory with a ${CONTRACT_FILE}, or a half folder whose ${MANIFEST_FILE} says what it \`implements\` (one, or plugins/<id>/ of a repo or a project).`)
   const ts = loadTypescript(plugins[0]!.dir)
   const root = resolve(path)
   const report: GenReport = { plugins: [], repo: { written: [], stale: [], fresh: [] }, failures: [] }
@@ -194,7 +221,7 @@ export const generate = (path: string, opts: { check?: boolean } = {}): GenRepor
     try {
       const { contract, manifest, files } = generatePlugin(ts, plugin)
       if (manifest) manifests.push({ id: plugin.id, manifest })
-      const entry = { id: plugin.id, contract, written: [] as string[], stale: [] as string[], fresh: [] as string[] }
+      const entry = { id: plugin.id, implements: manifest?.implements, contract, written: [] as string[], stale: [] as string[], fresh: [] as string[] }
       for (const f of files) place(f, entry)
       report.plugins.push(entry)
     } catch (e) {
@@ -206,9 +233,10 @@ export const generate = (path: string, opts: { check?: boolean } = {}): GenRepor
   }
 
   // A repo of plugins (not one plugin): its Package.swift, from every manifest that read. Written
-  // only when every contract made it — a repo with a broken plugin keeps the package it has.
-  const isRepo = !existsSync(join(root, CONTRACT_FILE))
-  if (isRepo && report.failures.length === 0 && manifests.some(m => m.manifest.ios)) {
+  // only when every contract made it — a repo with a broken plugin keeps the package it has — and
+  // only when one has an iOS half: a project whose plugins are web halves has no package to make.
+  const isRepo = !(plugins.length === 1 && plugins[0]!.dir === root)
+  if (isRepo && report.failures.length === 0 && manifests.some(m => m.manifest.ios !== null)) {
     try {
       place({ file: join(root, PACKAGE_FILE), text: emitPackageSwift(manifests, repoSdkPath(root)) }, report.repo)
     } catch (e) {

package/src/plugin/manifest.ts

@@ -1,19 +1,26 @@
 // A plugin's manifest (`lecodes-plugin.json`, 2.x): what a host needs to BUILD the plugin in — the
 // type that registers each half, what a half asks of its platform (usage strings, entitlements,
-// packages, Gradle dependencies, bundler resources). What the plugin DOES is not here: the channels,
-// their names and their types are the contract's (contract.d.ts), the folders are the convention
-// (`sdk/`, `ios/`, `android/`, `web/`).
+// packages, prebuilt binaries, Gradle dependencies, bundler resources). What the plugin DOES is not
+// here: the channels, their names and their types are the contract's (contract.d.ts), the folders
+// are the convention (`sdk/`, `ios/`, `android/`, `web/`).
 //
 // A platform is a key of the manifest, ALWAYS: an object where the plugin has a half, `null` where
 // it has none. A missing key is refused — "not supported" is a statement, not an omission.
 //
 // Desktop plugins are another system (a prebuilt library behind a C ABI) with a manifest of their
 // own shape; nothing of it is read here.
+//
+// A HALF FOLDER of a project (`implements: "<first-party id>"`) has no contract and no sdk/ of its
+// own: it implements the contract of a first-party plugin the SDK carries, for the platforms it has
+// a half of — app.json names it for those (`"ar": { "web": "./plugins/ar-8thwall" }`), the
+// first-party halves stay everywhere else.
 
 import { existsSync, readFileSync, statSync } from "node:fs"
-import { join } from "node:path"
+import { isAbsolute, join } from "node:path"
+import { firstPartyContractFile, firstPartyIds } from "./firstParty"
 
 export const MANIFEST_FILE = "lecodes-plugin.json"
+export const CONTRACT_FILE = "contract.d.ts"
 
 /** A SwiftPM dependency the iOS half links. */
 export type IosPackage = { url: string, exact?: string, from?: string, products: string[] }
@@ -30,6 +37,9 @@ export type PluginManifest = {
    *  contract between a bundle, the runtime and a half. */
   sdk: string
   description?: string
+  /** A HALF FOLDER: the first-party plugin whose contract the folder implements (it has no
+   *  contract.d.ts and no sdk/ of its own — the app's side is the SDK's wrapper). */
+  implements?: string
   ios: {
     /** The Swift module the half is built as in a shell. Default: `LeCodes` + the id in PascalCase. */
     module?: string
@@ -38,6 +48,12 @@ export type PluginManifest = {
     infoPlist?: Record<string, string>
     entitlements?: Record<string, unknown>
     packages?: IosPackage[]
+    /** Prebuilt xcframeworks the half links, by their paths in the plugin
+     *  (`binaries/ios/QrAnchorFFI.xcframework`): folders of the plugin, never under ios/ — SwiftPM
+     *  takes a binary as a target of its own, beside the sources. Each is a binary target named after
+     *  its folder (`binaryName`), which the half's target depends on; a name is one in a package
+     *  (two plugins may not carry one alike). */
+    binaries?: string[]
   } | null
   android: {
     /** The Gradle module the half is built as in a shell. Default: `lecodes-` + the id. */
@@ -56,6 +72,11 @@ export type PluginManifest = {
     dependencies?: Record<string, string>
     /** The half's bundler resources, by the name `register` receives them under. */
     resources?: Record<string, WebResource>
+    /** A folder of the plugin (relative to it) put beside the built module AS IS, names unhashed: a
+     *  runtime the half loads by its own url (`new URL("<static>/x.js", import.meta.url)`), which
+     *  fetches its files relative to itself. A project's half; the first-party halves are built in
+     *  Web Lite's page with `resources`. */
+    static?: string
   } | null
 }
 
@@ -69,16 +90,16 @@ const ID = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/
 const VERSION = /^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$/
 const RANGE = /^[\^~]?\d+\.\d+\.\d+$/
 const PLATFORMS = ["ios", "android", "web"] as const
-const KNOWN = new Set(["id", "name", "version", "sdk", "description", ...PLATFORMS])
+const KNOWN = new Set(["id", "name", "version", "sdk", "description", "implements", ...PLATFORMS])
 const GONE: Record<string, string> = {
   provides: "the channels are the contract's (contract.d.ts)",
   js: "the wrapper is found by convention (sdk/)",
   desktop: "desktop plugins are another system, with a manifest of their own",
 }
 const BRANCH: Record<(typeof PLATFORMS)[number], Set<string>> = {
-  ios: new Set(["module", "register", "infoPlist", "entitlements", "packages"]),
+  ios: new Set(["module", "register", "infoPlist", "entitlements", "packages", "binaries"]),
   android: new Set(["module", "register", "dependencies", "gradlePlugins"]),
-  web: new Set(["register", "dependencies", "resources"]),
+  web: new Set(["register", "dependencies", "resources", "static"]),
 }
 
 const isObject = (v: unknown): v is Record<string, unknown> => typeof v === "object" && v !== null && !Array.isArray(v)
@@ -86,6 +107,12 @@ const isFolder = (path: string): boolean => existsSync(path) && statSync(path).i
 
 export const pascal = (id: string): string => id.split("-").map(w => w.charAt(0).toUpperCase() + w.slice(1)).join("")
 
+const XCFRAMEWORK = ".xcframework"
+
+/** The binary target of an `ios.binaries` path: its folder's name without `.xcframework`
+ *  (`binaries/ios/QrAnchorFFI.xcframework` → `QrAnchorFFI`). */
+export const binaryName = (path: string): string => path.split(/[\\/]/).pop()!.slice(0, -XCFRAMEWORK.length)
+
 /** The manifest of the plugin in `dir` (its folder's name is its id). Every problem of the file is
  *  reported at once. */
 export const readManifest = (dir: string, id: string): PluginManifest => {
@@ -116,6 +143,13 @@ export const readManifest = (dir: string, id: string): PluginManifest => {
   const sdk = text("sdk")
   if (sdk !== undefined && !RANGE.test(sdk)) problems.push(`sdk: "${sdk}" — a range of the SDK's version: ^2.0.0`)
   if (raw.description !== undefined && typeof raw.description !== "string") problems.push("description: a text")
+  if (raw.implements !== undefined) {
+    const impl = raw.implements
+    if (typeof impl !== "string" || !ID.test(impl)) problems.push(`implements: the id of the first-party plugin whose contract the folder implements ("ar")`)
+    else if (!firstPartyContractFile(impl)) problems.push(`implements: "${impl}" is no first-party plugin of this SDK (${firstPartyIds().join(", ") || "it carries none"})`)
+    if (existsSync(join(dir, CONTRACT_FILE))) problems.push(`implements: the folder implements another plugin's contract — it has no ${CONTRACT_FILE} of its own`)
+    if (isFolder(join(dir, "sdk"))) problems.push("implements: the folder implements another plugin — its app side is the SDK's, it has no sdk/ of its own")
+  }
 
   for (const platform of PLATFORMS) {
     const branch = raw[platform]
@@ -159,6 +193,23 @@ export const readManifest = (dir: string, id: string): PluginManifest => {
         }
       })
     }
+    if (ios.binaries !== undefined) {
+      if (!Array.isArray(ios.binaries)) problems.push(`ios.binaries: a list of the plugin's xcframeworks, by their paths in it ("binaries/ios/X.xcframework")`)
+      else {
+        const named = new Map<string, string>()
+        ios.binaries.forEach((path, i) => {
+          const segments = typeof path === "string" ? path.split(/[\\/]/) : []
+          if (typeof path !== "string" || path.trim() === "" || isAbsolute(path) || segments.some(s => s === ".." || s === "." || s === "")) {
+            problems.push(`ios.binaries[${i}]: a folder of the plugin, by its path in it ("binaries/ios/X.xcframework")`)
+          } else if (!path.endsWith(XCFRAMEWORK)) problems.push(`ios.binaries[${i}]: "${path}" — an ${XCFRAMEWORK} folder`)
+          else if (segments[0] === "ios") problems.push(`ios.binaries[${i}]: ${path} is in ios/, the half's sources — a binary stands beside them ("binaries/ios/X.xcframework")`)
+          else if (!/^[A-Za-z_]\w*$/.test(binaryName(path))) problems.push(`ios.binaries[${i}]: "${path}" — the folder's name is its binary target's: a Swift name before ${XCFRAMEWORK}`)
+          else if (!isFolder(join(dir, path))) problems.push(`ios.binaries[${i}]: ${path} is not a folder of the plugin`)
+          else if (named.has(binaryName(path))) problems.push(`ios.binaries[${i}]: ${path} is named "${binaryName(path)}" like ${named.get(binaryName(path))} — a name is one binary target`)
+          else named.set(binaryName(path), path)
+        })
+      }
+    }
   }
   const android = isObject(raw.android) ? raw.android : null
   if (android) {
@@ -181,6 +232,14 @@ export const readManifest = (dir: string, id: string): PluginManifest => {
         }
       }
     }
+    const folder = web.static
+    if (folder !== undefined) {
+      const segments = typeof folder === "string" ? folder.split(/[\\/]/) : []
+      if (typeof folder !== "string" || folder.trim() === "" || isAbsolute(folder) || segments.some((s) => s === ".." || s === "." || s === "")) {
+        problems.push(`web.static: a folder of the plugin, by its path in it ("xr-runtime")`)
+      } else if (!isFolder(join(dir, folder))) problems.push(`web.static: ${folder} is not a folder of the plugin`)
+      else if (folder === "index.js") problems.push(`web.static: "index.js" is the built module's name`)
+    }
   }
 
   if (problems.length) throw new ManifestError(file, problems)