@evertondgn/solid-tooling 0.1.0 → 0.2.0

package/README.md

@@ -1,21 +1,50 @@
 # @evertondgn/solid-tooling
 
-Lint, formatador e base do TypeScript para aplicações SolidJS construídas com
-Vite+. O pacote é distribuído compilado: o Node recusa TypeScript dentro de
-`node_modules`, e o Vite+ carrega a configuração em Node.
+Lint preset, formatter config and TypeScript base for SolidJS 2 applications
+built with [Vite+](https://viteplus.dev/guide/).
 
-## Instalação
+The package contains the lint, format and TypeScript setup of
+[boilerplate_solidjs](https://github.com/everton-dgn/boilerplate_solidjs), a
+SolidJS application template. Applications created from it install the package
+instead of copying the files, so a rule change reaches them through a version
+update.
+
+## Requirements
+
+The application installs three packages next to this one:
+
+| Package                | Why                                                         |
+| ---------------------- | ----------------------------------------------------------- |
+| `vite-plus`            | Runs lint and format, and provides the Oxlint plugin API    |
+| `@inlang/paraglide-js` | The preset registers its lint plugin, resolved from the app |
+| `typescript`           | The preset turns on type-aware linting and type checking    |
+
+`vite-plus` and `@inlang/paraglide-js` are peer dependencies, pinned to the
+exact versions the package is tested with. Install the versions listed in its
+`peerDependencies`. `typescript` is not a peer dependency: the package is tested
+with the version in its `devDependencies`.
+
+`eslint-plugin-solid` comes with the package, so the application does not
+declare it.
+
+## Install
+
+`vp` is the Vite+ CLI. An application built with Vite+ already has `vite-plus`
+and `typescript`, so it only adds this package:
 
 ```bash
 vp add -D @evertondgn/solid-tooling
 ```
 
-A aplicação também declara o `vite-plus` e o `@inlang/paraglide-js`. O Oxlint
-resolve os plugins a partir da configuração da aplicação, e o plugin do
-Paraglide precisa acompanhar a versão que ela usa. O `eslint-plugin-solid` vem
-como dependência do pacote e dispensa declaração.
+An application without `@inlang/paraglide-js` adds it too, in the version the
+package asks for:
 
-## Uso
+```bash
+npm view @evertondgn/solid-tooling peerDependencies
+vp add -D @inlang/paraglide-js@<version>
+```
+
+## Usage
 
 ```ts
 // vite.config.ts
@@ -29,25 +58,201 @@ export default defineConfig({ fmt, lint })
 ```json
 // tsconfig.json
 {
-  "extends": "@evertondgn/solid-tooling/tsconfig.base.json"
+  "extends": "@evertondgn/solid-tooling/tsconfig.base.json",
+  "compilerOptions": {
+    "paths": { "@/*": ["./src/*"] }
+  },
+  "include": ["src", "vite.config.ts"]
 }
 ```
 
-`paths`, `include` e `types` continuam no `tsconfig.json` da aplicação.
+`vp check`, `vp lint` and `vp fmt` read both configs from `vite.config.ts`.
+
+## Project layout the preset expects
+
+The rules match file paths relative to the folder where lint runs, so run it
+from the application root. They know these locations:
+
+| Path                                          | Meaning                                                  |
+| --------------------------------------------- | -------------------------------------------------------- |
+| `src/`                                        | Application code. The `@/` alias points here             |
+| `src/routes/`                                 | Pages. Each page may have a `seo.ts` module              |
+| `src/components/{atoms,molecules,organisms}/` | UI layers                                                |
+| `src/primitives/`                             | Shared primitives                                        |
+| `src/infra/server/`                           | Backend adapters and server error handling               |
+| `src/theme/`                                  | Global CSS                                               |
+| `src/tests/pages/<Page>/`                     | End-to-end tests, one folder per page                    |
+| `paraglide/`                                  | Generated i18n modules. The `@paraglide/` alias          |
+| `tooling/`                                    | Project scripts and their tests, written for `node:test` |
+
+An application with another layout can still use the preset, but it has to
+override the rules that do not fit. See
+[Changing the preset](#changing-the-preset).
+
+## What the lint preset turns on
+
+- Oxlint plugins: `import`, `jsx-a11y`, `node`, `oxc`, `promise`, `typescript`,
+  `unicorn` and `vitest`.
+- JavaScript plugins: `solid`, `paraglide`, `vite-plus` and the three plugins of
+  this package (`project`, `backend`, `architecture`).
+- Type-aware rules and type checking (`typeAware`, `typeCheck`).
+- Warnings fail the run (`denyWarnings`), and an unused disable directive is an
+  error.
+
+Every rule is listed by name in the preset. No Oxlint category is enabled, so an
+Oxlint update does not add rules on its own.
+
+### Rules of this package
+
+| Rule                                      | What it enforces                                                                                                                                           |
+| ----------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `project/css-modules-import`              | A CSS Module is imported as the default binding `S`                                                                                                        |
+| `project/css-filename`                    | A CSS file imported from `src/` is named `styles.module.css`, or `camelCase.css` inside `src/theme/`                                                       |
+| `project/test-filename`                   | A test file sits in `__tests__` next to its module and is named after it, plus the environment: `Button/__tests__/Button.dom.test.tsx`                     |
+| `project/no-export-list`                  | Exports sit on the declaration. `export { a, b }` is only allowed with `from`                                                                              |
+| `project/seo-module`                      | A route `seo.ts` exports only `seo`. It has no relative value import, no value import from `src/routes/`, no computed `import()` and no `import.meta.glob` |
+| `backend/static-solid-imports`            | No `import()` of `@solidjs/web` or its subpaths                                                                                                            |
+| `backend/static-render-integrity-imports` | No `import()` of the `renderIntegrity` module                                                                                                              |
+| `architecture/layer-imports`              | Lower layers do not import upper ones, and production code does not import tests or `tooling/`                                                             |
+
+These rules read import specifiers as text. They resolve relative paths and the
+`@/`, `@paraglide/` and `/src/` prefixes. An `import()` with a computed path and
+any other alias are not checked, except in `seo.ts`, where a computed `import()`
+is an error.
+
+`architecture/layer-imports` checks these directions:
+
+- The base layer (`src/@types`, `constants`, `helpers`, `data`, `infra`,
+  `theme`, `i18n` and `paraglide/`) does not import primitives, components,
+  routes or entry files.
+- `src/primitives` does not import components, routes or entry files.
+- Atoms do not import molecules or organisms, and molecules do not import
+  organisms.
+- No production file imports a test or `tooling/`.
+
+The entry files are `App`, `Document`, `entry-server`, `entry-client`, `router`
+and `middleware`, at the root of `src/`.
+
+`project/test-filename` accepts these names:
+
+- `Name.<environment>.test.ts(x)` in `src/`, where the environment is `node`,
+  `dom`, `browser` or `e2e`.
+- `Name.test-d.ts(x)` in `src/`, for type tests.
+- `Name.test.ts` in `tooling/`.
+
+`Name` is the folder that holds `__tests__`. A qualifier may follow it:
+`Button.focus.dom.test.tsx`. End-to-end tests are the exception: they live in
+`src/tests/pages/<Page>/` and are named after the page.
+
+### Backend restrictions
+
+Inside `src/`, the preset also restricts what code can reach:
+
+- `console` is not allowed. `src/infra/server/logServerFailure/index.ts` is the
+  only module that may call `console.error`.
+- `fetch`, `XMLHttpRequest`, `WebSocket` and `EventSource` are not allowed.
+  `src/infra/server/requestJson/index.ts` is the only module that may call
+  `fetch`.
+- The Node transports (`http`, `https`, `http2`, `net`, `tls`, `undici`) cannot
+  be imported.
+- `markSafeError` and `SAFE_ERROR` can only be imported in
+  `src/infra/server/publicErrors/index.ts`.
+- `configureServerErrors` from `@solidjs/web`, the
+  `@solidjs/web/server-functions` subpath and `observeRenderFailures` from the
+  application's `renderIntegrity` module can only be imported in
+  `src/infra/server/configureServerErrors/index.ts`.
+- A relative import goes up at most three levels. Use `@/` beyond that.
+
+Test files and `.d.ts` files are exempt from all of these except the relative
+import limit.
+
+## Changing the preset
+
+`lint` and `fmt` are plain objects. Spread them and replace what the application
+needs:
+
+```ts
+// vite.config.ts
+import { fmt } from '@evertondgn/solid-tooling/fmt'
+import { lint } from '@evertondgn/solid-tooling/lint'
+import { defineConfig } from 'vite-plus'
+
+export default defineConfig({
+  fmt,
+  lint: {
+    ...lint,
+    ignorePatterns: [...(lint.ignorePatterns ?? []), 'generated/**'],
+    rules: { ...lint.rules, 'eslint/max-params': 'off' }
+  }
+})
+```
+
+Do not replace `lint.jsPlugins`. It registers the JavaScript plugins listed
+above, and a rule whose plugin is missing from it fails to resolve.
+
+To turn a rule off for some files only, add an entry to `lint.overrides` and
+keep the existing ones:
+
+```ts
+overrides: [
+  ...(lint.overrides ?? []),
+  {
+    files: ['src/tests/pages/Checkout/**'],
+    rules: { 'project/test-filename': 'off' }
+  }
+]
+```
+
+## Entry points
+
+| Entry                   | Content                                                                   |
+| ----------------------- | ------------------------------------------------------------------------- |
+| `./lint`                | `lint`: the lint preset, with the plugins below registered                |
+| `./fmt`                 | `fmt`: the formatter config                                               |
+| `./tsconfig.base.json`  | Compiler options, without application paths                               |
+| `./project-plugin`      | The `project` rules                                                       |
+| `./backend-plugin`      | The `backend` rules                                                       |
+| `./architecture-plugin` | The `architecture` rule                                                   |
+| `./solid-plugin`        | Re-export of `eslint-plugin-solid`                                        |
+| `./css-filename`        | `cssFilenameError(path)`, the CSS naming check, for a script outside lint |
+
+An application only imports `./lint`, `./fmt` and `./tsconfig.base.json`. The
+plugin entries exist because Oxlint loads plugins by specifier, from the
+application.
+
+## Formatter
+
+`fmt` sets 80 columns, single quotes, no semicolons, no trailing commas, wrapped
+prose in Markdown and sorted imports. It ignores `public/`, `src/assets/`,
+generated route types, SVG and lock files.
+
+## TypeScript base
+
+`tsconfig.base.json` targets ES2024 with bundler resolution, keeps JSX for the
+Solid compiler (`jsxImportSource: @solidjs/web`), emits nothing and turns on the
+unused code and unchecked index checks. It has no `paths`, `include` or `types`:
+those depend on the application and stay in its `tsconfig.json`.
+
+## Known limits
+
+- The package ships compiled JavaScript. Node refuses to run TypeScript from
+  `node_modules`, and Vite+ loads `vite.config.ts` in Node.
+- `project/test-filename` has no options. Test folders without a module, such as
+  the page tests in `src/tests/pages/`, are listed inside the package with the
+  names used in boilerplate_solidjs. For any other folder of that kind, turn the
+  rule off in `lint.overrides`, as shown in
+  [Changing the preset](#changing-the-preset).
+- The Paraglide plugin is always registered, so `@inlang/paraglide-js` has to be
+  installed even in an application without translations.
+- Some rule messages point to `docs/architecture.md` and `AGENTS.md`. Those
+  files belong to the application created from boilerplate_solidjs.
+
+## Versions
 
-## Entradas
+The package follows semantic versioning. Below 1.0.0, a breaking change raises
+the minor version. Each release is listed in the
+[changelog](https://github.com/everton-dgn/solidjs_base/blob/main/packages/solid-tooling/CHANGELOG.md).
 
-| Entrada                 | Conteúdo                                                    |
-| ----------------------- | ----------------------------------------------------------- |
-| `./lint`                | Preset de lint, com os plugins abaixo já registrados        |
-| `./fmt`                 | Configuração do formatador                                  |
-| `./project-plugin`      | Regras de exports, nomes de arquivos de teste e de CSS, SEO |
-| `./backend-plugin`      | Imports estáticos das APIs privilegiadas do servidor        |
-| `./architecture-plugin` | Dependências entre camadas                                  |
-| `./solid-plugin`        | Reexport do `eslint-plugin-solid`                           |
-| `./css-filename`        | Regra de nome de arquivo CSS, para o script de lint de CSS  |
-| `./tsconfig.base.json`  | Opções do compilador sem caminhos da aplicação              |
+## License
 
-O preset pressupõe o layout das aplicações derivadas do `boilerplate_solidjs`:
-código em `src/`, ferramentas em `tooling/` e as camadas descritas no guia de
-arquitetura da aplicação.
+MIT

package/dist/architecture-plugin.mjs

@@ -41,7 +41,7 @@ const layerImports = defineRule({
 	meta: {
 		type: "problem",
 		schema: [],
-		messages: { forbidden: "A camada {{from}} não pode depender de {{to}} ({{target}}). Consulte as regras de camadas em docs/architecture.md." }
+		messages: { forbidden: "Layer {{from}} must not depend on {{to}} ({{target}}). See the layer rules in docs/architecture.md." }
 	},
 	create(context) {
 		const from = layer(path.relative(context.cwd, context.filename).split(path.sep).join("/"));

package/dist/backend-plugin.mjs

@@ -1,5 +1,5 @@
 import { t as readStaticSpecifier } from "./import-specifier-C7HWhMXB.mjs";
-import { n as RENDER_INTEGRITY_MODULE } from "./constants-DwOmJ9No.mjs";
+import { n as RENDER_INTEGRITY_MODULE } from "./constants-Jqvtbvxu.mjs";
 import { definePlugin, defineRule } from "vite-plus/lint/plugins";
 // src/backendPolicy/plugin.ts
 const RENDER_INTEGRITY = new RegExp(RENDER_INTEGRITY_MODULE, "u");
@@ -26,11 +26,11 @@ const backendPlugin = definePlugin({
 	rules: {
 		"static-solid-imports": staticImportRule({
 			matches: (specifier) => specifier === "@solidjs/web" || specifier.startsWith("@solidjs/web/"),
-			message: "Use import estático de @solidjs/web e seus subcaminhos para preservar as restrições de APIs privilegiadas."
+			message: "Use a static import for @solidjs/web and its subpaths: the import restrictions on markSafeError and configureServerErrors cannot check import()."
 		}),
 		"static-render-integrity-imports": staticImportRule({
 			matches: (specifier) => RENDER_INTEGRITY.test(specifier),
-			message: "Use import estático de renderIntegrity para preservar a restrição de observeRenderFailures."
+			message: "Use a static import for renderIntegrity: the import restriction on observeRenderFailures cannot check import()."
 		})
 	}
 });

package/dist/{constants-DwOmJ9No.mjs → constants-Jqvtbvxu.mjs}

@@ -1,7 +1,7 @@
 // src/backendPolicy/constants.ts
 const RELATIVE_IMPORT_RESTRICTION = {
 	regex: String.raw`^(\.\./){4,}`,
-	message: "Imports relativos podem subir no máximo três níveis. Use o alias @/ para caminhos mais distantes."
+	message: "Relative imports may go up at most three levels. Use the @/ alias for more distant paths."
 };
 const RENDER_INTEGRITY_MODULE = String.raw`(?:^|/)renderIntegrity(?:/index(?:\.ts)?)?$`;
 export { RENDER_INTEGRITY_MODULE as n, RELATIVE_IMPORT_RESTRICTION as t };

package/dist/css-filename.mjs

@@ -5,8 +5,8 @@ import path from "node:path";
 function cssFilenameError(file) {
 	const normalized = file.split("\\").join("/");
 	const basename = path.posix.basename(normalized);
-	if (normalized.startsWith("src/theme/")) return /^[a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)*$/u.test(basename.slice(0, -4)) ? void 0 : "Use nomeCamelCase.css dentro de src/theme/.";
-	return basename === "styles.module.css" ? void 0 : "Use styles.module.css fora de src/theme/, inclusive nas rotas.";
+	if (normalized.startsWith("src/theme/")) return /^[a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)*$/u.test(basename.slice(0, -4)) ? void 0 : "Use camelCaseName.css inside src/theme/.";
+	return basename === "styles.module.css" ? void 0 : "Use styles.module.css outside src/theme/, including in routes.";
 }
 const cssFilename = defineRule({
 	meta: {

package/dist/lint.mjs

@@ -1,4 +1,4 @@
-import { n as RENDER_INTEGRITY_MODULE, t as RELATIVE_IMPORT_RESTRICTION } from "./constants-DwOmJ9No.mjs";
+import { n as RENDER_INTEGRITY_MODULE, t as RELATIVE_IMPORT_RESTRICTION } from "./constants-Jqvtbvxu.mjs";
 // src/backendPolicy/index.ts
 const NETWORK = [
 	"fetch",
@@ -16,21 +16,21 @@ const GLOBALS = [
 const SAFE_ERRORS = {
 	name: "@solidjs/web",
 	importNames: ["markSafeError", "SAFE_ERROR"],
-	message: "Use createPublicError; somente publicErrors autoriza erros públicos."
+	message: "Use createPublicError; only publicErrors may mark an error as public."
 };
 const SERVER_ERROR_HOOK = {
 	name: "@solidjs/web",
 	importNames: ["configureServerErrors"],
-	message: "Mantenha o registro da política em configureServerErrors."
+	message: "Only src/infra/server/configureServerErrors/index.ts may import this: server error handling is configured in that module."
 };
 const SERVER_CONFIG = ["@solidjs/web/server-functions", "@solidjs/web/server-functions/server"].map((name) => ({
 	name,
-	message: "Mantenha o registro da política em configureServerErrors."
+	message: "Only src/infra/server/configureServerErrors/index.ts may import this: server error handling is configured in that module."
 }));
 const RENDER_OBSERVER = {
 	regex: RENDER_INTEGRITY_MODULE,
 	importNames: ["observeRenderFailures"],
-	message: "Somente configureServerErrors declara que as falhas de render são observadas."
+	message: "Only configureServerErrors may declare that render failures are observed."
 };
 const TRANSPORTS = [
 	"http",
@@ -41,7 +41,7 @@ const TRANSPORTS = [
 	"undici"
 ].flatMap((name) => [name, `node:${name}`]).map((name) => ({
 	name,
-	message: "Integre transportes de backend em um adapter protegido."
+	message: "Node transports cannot be imported in src/. Use requestJson for HTTP, or an adapter in src/infra/server/ wrapped in protectServerOperation."
 }));
 function imports({ paths, patterns = [] }) {
 	return { "eslint/no-restricted-imports": ["error", {
@@ -59,7 +59,7 @@ function globals({ names, properties = names }) {
 		"eslint/no-restricted-properties": ["error", ...GLOBALS.flatMap((object) => properties.map((property) => ({
 			object,
 			property,
-			message: property === "console" ? "Registre falhas somente por logServerFailure." : "Use requestJson ou um adapter de backend protegido."
+			message: property === "console" ? "Log failures only through logServerFailure." : "Call the backend through requestJson, or through an adapter in src/infra/server/ wrapped in protectServerOperation."
 		})))]
 	};
 }

package/dist/project-plugin.mjs

@@ -7,7 +7,7 @@ const noExportList = defineRule({
 	meta: {
 		type: "suggestion",
 		schema: [],
-		messages: { inlineExport: "Declare o export junto da declaração (export function, export const, export type) em vez de usar export { ... }. Lista de exports só vale em reexport com from." }
+		messages: { inlineExport: "Export on the declaration itself (export function, export const, export type) instead of using export { ... }. An export list is only allowed in a re-export with from." }
 	},
 	create(context) {
 		return { ExportNamedDeclaration(node) {
@@ -32,10 +32,10 @@ const seoModule = defineRule({
 		type: "problem",
 		schema: [],
 		messages: {
-			onlySeo: "O seo.ts exporta só o objeto seo. O corpo da página fica no index.tsx, porque o seo.ts entra no bundle inicial pelo route (AGENTS.md, Módulos de página).",
-			localImport: "O seo.ts não importa módulos locais como valor: o que ele importa entra no bundle inicial junto com o route. Mantenha o corpo da página no index.tsx (AGENTS.md, Módulos de página).",
-			computedImport: "O seo.ts não usa import() com caminho calculado: a regra não consegue conferir se o destino é local. Mantenha o corpo da página no index.tsx (AGENTS.md, Módulos de página).",
-			globImport: "O seo.ts não usa import.meta.glob: o Vite o converte em imports dos módulos que o padrão casa. Mantenha o corpo da página no index.tsx (AGENTS.md, Módulos de página)."
+			onlySeo: "seo.ts may export only seo. The route manifest loads the route export of every page in the initial bundle, and seo.ts goes with it, so keep the page body in index.tsx (see the page modules section of AGENTS.md).",
+			localImport: "seo.ts must not import values from relative paths or from src/routes/: whatever it imports goes into the initial bundle. Use import type, or keep the code in index.tsx (see the page modules section of AGENTS.md).",
+			computedImport: "seo.ts must not use import() with a computed path: the rule cannot tell whether the target is local. Keep the page body in index.tsx (see the page modules section of AGENTS.md).",
+			globImport: "seo.ts must not use import.meta.glob: Vite turns it into imports of every module the pattern matches. Keep the page body in index.tsx (see the page modules section of AGENTS.md)."
 		}
 	},
 	create(context) {
@@ -155,13 +155,13 @@ function testFilenameError(file) {
 	});
 	const candidate = dotted ? `${DOTTED_SUBJECT}${basename.slice(dotted.length)}` : basename;
 	const match = normalized.startsWith("tooling/") ? /^(?<subject>[^.]+)(?<qualifiers>(?:\.[a-z][a-zA-Z0-9]*)*)\.test\.ts$/u.exec(candidate) : /^(?<subject>[^.]+)(?<qualifiers>(?:\.[a-z][a-zA-Z0-9]*)*)(?:\.(?<environment>node|dom|browser|e2e)\.test|\.test-d)\.tsx?$/u.exec(candidate);
-	if (!match?.groups) return "Use Nome[.qualificador].ambiente.test.ts(x) ou Nome[.qualificador].test-d.ts(x) para tipos em src, ou Nome[.qualificador].test.ts em tooling.";
+	if (!match?.groups) return "In src/, name the test Name[.qualifier].<node|dom|browser|e2e>.test.ts(x), or Name[.qualifier].test-d.ts(x) for a type test. In tooling/, use Name[.qualifier].test.ts.";
 	const { environment } = match.groups;
 	const subject = dotted ?? match.groups.subject;
-	if (inPages && environment !== "e2e") return "Testes de páginas devem usar o ambiente e2e.";
-	if (environment === "e2e" && (!inPages || !subjects[directory])) return "Coloque testes e2e em src/tests/pages/NomeDaPagina e declare a página no mapeamento.";
-	if (!expected) return "Coloque o teste em __tests__ junto ao módulo ou declare sua suíte no mapeamento de tooling/test-filename.ts.";
-	if (!subject || !expected.includes(subject)) return `Use o nome exato do assunto testado: ${expected.join(", ")}. Qualificadores usam ponto e camelCase.`;
+	if (inPages && environment !== "e2e") return "Page tests must use the e2e environment.";
+	if (environment === "e2e" && (!inPages || !subjects[directory])) return "Place e2e tests in src/tests/pages/<Page>/. The accepted pages are listed in @evertondgn/solid-tooling; for another page, turn off project/test-filename for its folder in lint.overrides.";
+	if (!expected) return "Place the test in a __tests__ folder inside the module folder, as in Button/__tests__/Button.dom.test.tsx. For a test folder without a module, turn off project/test-filename for its files in lint.overrides.";
+	if (!subject || !expected.includes(subject)) return `Use the exact name of the subject under test: ${expected.join(", ")}. Qualifiers use a dot and camelCase.`;
 }
 const testFilename = defineRule({
 	meta: {
@@ -183,7 +183,7 @@ const cssModulesImport = defineRule({
 	meta: {
 		type: "suggestion",
 		schema: [],
-		messages: { useS: "Importe CSS Modules como S: import S from \"./styles.module.css\"." }
+		messages: { useS: "Import CSS Modules as S: import S from \"./styles.module.css\"." }
 	},
 	create(context) {
 		return { ImportDeclaration(node) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evertondgn/solid-tooling",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Lint, formatter and TypeScript presets for SolidJS applications built with Vite+.",
   "author": "Éverton Toffanetto",
   "license": "MIT",
@@ -39,8 +39,7 @@
     "build": "vp pack",
     "dev": "vp pack --watch",
     "test": "vp run test-rules",
-    "test:tarball": "vp run test-tarball",
-    "prepublishOnly": "vp pack"
+    "test:tarball": "vp run test-tarball"
   },
   "dependencies": {
     "eslint-plugin-solid": "0.19.0"