@systemfsoftware/oxlint-plugin-cell-vocabulary 1.0.0

package/LICENSE

@@ -0,0 +1,203 @@
+Copyright (c) 2026 Ryan Lee (systemfsoftware)
+
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Ryan Lee (systemfsoftware)
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,40 @@
+# @systemfsoftware/oxlint-plugin-cell-vocabulary
+
+Oxlint rules that decide the phase purity and I/O-cell vocabulary of a Cell description by walking Cell.vocabulary, and report I/O reached from the body of a phase whose kind forbids it.
+
+## Install
+
+```sh
+pnpm add @systemfsoftware/oxlint-plugin-cell-vocabulary 'effect@4.0.0-rc.108' 'typescript@>=5.0.0'
+```
+
+Those are peer dependencies: this package declares them but does not install them, so one copy is shared with the rest of your project.
+
+## Entry points
+
+- `@systemfsoftware/oxlint-plugin-cell-vocabulary`
+
+## Use
+
+Register the plugin and enable what it recommends:
+
+```ts
+// oxlint.config.ts
+import plugin from '@systemfsoftware/oxlint-plugin-cell-vocabulary'
+import { defineConfig } from 'oxlint'
+
+export default defineConfig({
+  jsPlugins: [import.meta.resolve('@systemfsoftware/oxlint-plugin-cell-vocabulary')],
+  rules: { ...plugin.configs.recommended.rules },
+})
+```
+
+A rule configured without its plugin registered is reported as unknown and never runs, so both halves are required.
+
+## API
+
+The public surface is generated from the source and versioned with the package: [`etc/oxlint-plugin-cell-vocabulary.api.md`](./etc/oxlint-plugin-cell-vocabulary.api.md).
+
+## License
+
+Apache-2.0. Part of [systemfsoftware](https://github.com/systemfsoftware/systemfsoftware/tree/main/packages/oxlint-plugins/cell-vocabulary#readme).

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+//#region src/index.d.ts
+declare const _default: {
+  meta: {
+    name: string;
+  };
+  rules: {
+    'no-io-in-phase-bodies': import("@oxlint/plugins").Rule;
+  };
+  configs: {
+    recommended: {
+      rules: {
+        readonly [x: string]: "error";
+      };
+    };
+  };
+};
+//#endregion
+export { _default as default };

package/dist/index.mjs

@@ -0,0 +1,208 @@
+import { defineRule } from "@oxlint/plugins";
+import { Array, Schema } from "effect";
+import { Cell } from "@systemfsoftware/effect-cell-types";
+//#region src/rules/cell.ts
+const PathSegments = Schema.NonEmptyArray(Schema.String);
+const lastSegmentOf = (source) => Array.lastNonEmpty(Schema.decodeUnknownSync(PathSegments)(source.split("/")));
+const MODULE_EXTENSIONS = [
+	".js",
+	".ts",
+	".mjs",
+	".mts"
+];
+const stripExtension = (segment) => {
+	const extension = MODULE_EXTENSIONS.find((candidate) => segment.endsWith(candidate));
+	return extension === void 0 ? segment : segment.slice(0, -extension.length);
+};
+/**
+* The cell a module source belongs to, restricted to the walked I/O cells: a source
+* whose last segment ends in one of those cell suffixes is an I/O module, and a
+* binding imported from it is an I/O binding. The suffix set rides the import edge
+* and is never inferred from an identifier's spelling (EE1).
+*/
+const cellOf = (source, cells) => {
+	const stem = stripExtension(lastSegmentOf(source));
+	return cells.find((cell) => stem.endsWith(`.${cell}`)) ?? null;
+};
+/** `saveOrder(...)` -> `saveOrder`; `Store.save(...)` -> `Store`. */
+const calleeRootName = (callee) => {
+	if (callee.type === "Identifier") return callee.name;
+	if (callee.type !== "MemberExpression") return null;
+	return calleeRootName(callee.object);
+};
+//#endregion
+//#region src/rules/no-io-in-phase-bodies.config.ts
+const Options = Schema.Struct({});
+/**
+* The export name of the description vocabulary on its own module. A description is
+* recognised by an import from `Cell.vocabulary.module`; among that module's exports
+* only this one carries the phase constructors, so a named import of any other export
+* (Policy, Workflow) must not be treated as a description namespace.
+*/
+const DESCRIPTION_NAMESPACE = "Cell";
+/**
+* The phases whose kind forbids I/O, read off the walked vocabulary's own partition by
+* kind. Purity is not inferred here: deriving it from the invocation shape is a different
+* axis, and it disagrees the moment a pure phase is given an effectful shape or an impure
+* one is not.
+*/
+const PURE_PHASE_NAMES = Cell.vocabulary.byKind.pure;
+/** The pure phase names as one string, for the message's {{phases}} slot. */
+const PURE_PHASE_LIST = PURE_PHASE_NAMES.join(", ");
+/** The description package's own module name, walked off the vocabulary. */
+const MODULE_SOURCE = Cell.vocabulary.module;
+/** The cells whose calls are I/O, walked off the vocabulary. */
+const IO_CELLS = Cell.vocabulary.ioCells.cells;
+/** The non-cell module sources whose calls are I/O, walked off the vocabulary. */
+const IO_SOURCES = Cell.vocabulary.ioCells.sources;
+if (PURE_PHASE_NAMES.length === 0) throw new Error(`${DESCRIPTION_NAMESPACE}: the walked vocabulary reports no pure phase, so this rule would decide nothing`);
+if (IO_CELLS.length === 0 && IO_SOURCES.length === 0) throw new Error(`${DESCRIPTION_NAMESPACE}: the walked I/O classification is empty, so this rule would decide nothing`);
+const SKIPPED_WALK_KEYS = [
+	"parent",
+	"range",
+	"loc",
+	"start",
+	"end"
+];
+const IO_IN_PHASE_BODY_EXPECTED = "a {{phases}} phase body that only transforms the value it receives, with no I/O call written inside it or in a module-level helper it calls";
+const IO_IN_PHASE_BODY_ACTUAL = "an I/O call written inside the body of a {{phases}} phase — at any depth within that body, or in a module-level helper the body calls";
+const IO_IN_PHASE_BODY_FIX = "hoist the I/O into a phase whose kind permits it and pass the value in as the body receives it; when nothing consumes the call, delete it";
+const meta = {
+	type: "problem",
+	docs: { description: "Report an I/O call reached from the body of a phase whose kind forbids it, in a file that imports the description vocabulary — directly, or through a locally-declared helper the phase body calls. The phase set, the I/O-cell classification and the description module are all walked off Cell.vocabulary, never restated." },
+	schema: [Options],
+	messages: { ioInPhaseBody: "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}." }
+};
+//#endregion
+//#region src/rules/no-io-in-phase-bodies.ts
+const isWalkable = (value) => typeof value === "object" && value !== null;
+const nodeType = (node) => String(node["type"]);
+const walk = (value, visit) => {
+	if (!isWalkable(value)) return;
+	visit(value);
+	for (const key of Object.keys(value)) {
+		if (SKIPPED_WALK_KEYS.some((skipped) => skipped === key)) continue;
+		walk(value[key], visit);
+	}
+};
+const isCallExpression = (value) => nodeType(value) === "CallExpression";
+/**
+* The pure phase a call targets, or null when the callee is not one. The object must
+* be a local binding of the description module's `Cell` export — never a name that
+* merely spells like one, and never another export of the same module.
+*/
+const purePhaseNameOf = (callee, namespaces) => {
+	if (callee.type !== "MemberExpression") return null;
+	const object = callee.object;
+	if (object.type !== "Identifier") return null;
+	if (!namespaces.has(object.name)) return null;
+	const property = callee.property;
+	const propertyName = property.type === "Identifier" ? property.name : null;
+	return PURE_PHASE_NAMES.some((phase) => phase === propertyName) ? propertyName : null;
+};
+const noIoInPhaseBodies = defineRule({
+	meta,
+	create(context) {
+		const descriptionNamespaces = /* @__PURE__ */ new Set();
+		const ioNames = /* @__PURE__ */ new Set();
+		const localHelpers = /* @__PURE__ */ new Map();
+		/**
+		* Reports every I/O call reachable from a pure phase body: directly, or through a
+		* locally-declared helper the body calls, whose own body is walked the same way.
+		* The closure branch follows the local binding to its declaration in the same
+		* file; a helper already visited is not re-walked, so mutual recursion terminates.
+		*/
+		const reportIoInBody = (body, visited) => {
+			walk(body, (inner) => {
+				if (!isCallExpression(inner)) return;
+				const innerRoot = calleeRootName(inner.callee);
+				if (innerRoot === null) return;
+				if (ioNames.has(innerRoot)) {
+					context.report({
+						node: inner,
+						messageId: "ioInPhaseBody",
+						data: {
+							name: innerRoot,
+							expected: IO_IN_PHASE_BODY_EXPECTED.replace("{{phases}}", PURE_PHASE_LIST),
+							actual: IO_IN_PHASE_BODY_ACTUAL.replace("{{phases}}", PURE_PHASE_LIST),
+							fix: IO_IN_PHASE_BODY_FIX
+						}
+					});
+					return;
+				}
+				const helper = localHelpers.get(innerRoot);
+				if (helper === void 0 || visited.has(helper)) return;
+				const next = new Set(visited);
+				next.add(helper);
+				reportIoInBody(helper, next);
+			});
+		};
+		/**
+		* Imports are classified here rather than in an `ImportDeclaration` listener. Listeners fire in
+		* document order, so a phase call written above its own import would be judged against empty
+		* sets — and with no I/O name registered the rule reports nothing at all. That is a silent pass
+		* decided by line order, which is the one failure a guard must not have. `Program` sees every
+		* top-level statement before any call is visited, so the sets are complete when the first call
+		* is judged.
+		*/
+		const classifyImport = (node) => {
+			const source = node.source.value;
+			if (source === MODULE_SOURCE) {
+				for (const specifier of node.specifiers) if (specifier.type === "ImportNamespaceSpecifier") descriptionNamespaces.add(specifier.local.name);
+				else if (specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === "Cell") descriptionNamespaces.add(specifier.local.name);
+				return;
+			}
+			if (IO_SOURCES.some((ioSource) => ioSource === source)) {
+				for (const specifier of node.specifiers) ioNames.add(specifier.local.name);
+				return;
+			}
+			if (cellOf(source, IO_CELLS) === null) return;
+			for (const specifier of node.specifiers) ioNames.add(specifier.local.name);
+		};
+		return {
+			Program(node) {
+				for (const statement of node.body) {
+					if (statement.type === "ImportDeclaration") {
+						classifyImport(statement);
+						continue;
+					}
+					const declaration = statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration : statement;
+					if (declaration === null) continue;
+					if (declaration.type === "FunctionDeclaration") {
+						if (declaration.id !== null) localHelpers.set(declaration.id.name, declaration);
+					} else if (declaration.type === "VariableDeclaration") for (const inner of declaration.declarations) {
+						const init = inner.init;
+						if (init === null) continue;
+						if (init.type !== "ArrowFunctionExpression" && init.type !== "FunctionExpression") continue;
+						if (inner.id.type !== "Identifier") continue;
+						localHelpers.set(inner.id.name, init);
+					}
+				}
+			},
+			CallExpression(node) {
+				if (purePhaseNameOf(node.callee, descriptionNamespaces) === null) return;
+				for (const argument of node.arguments) {
+					if (argument.type === "ArrowFunctionExpression" || argument.type === "FunctionExpression") {
+						reportIoInBody(argument, /* @__PURE__ */ new Set());
+						continue;
+					}
+					if (argument.type !== "Identifier") continue;
+					const helper = localHelpers.get(argument.name);
+					if (helper !== void 0) reportIoInBody(helper, /* @__PURE__ */ new Set([helper]));
+				}
+			}
+		};
+	}
+});
+//#endregion
+//#region src/index.ts
+const PLUGIN_NAME = "@systemfsoftware/oxlint-plugin-cell-vocabulary";
+const rule = (name) => `${PLUGIN_NAME}/${name}`;
+const recommendedRules = { [rule("no-io-in-phase-bodies")]: "error" };
+var src_default = {
+	meta: { name: PLUGIN_NAME },
+	rules: { "no-io-in-phase-bodies": noIoInPhaseBodies },
+	configs: { recommended: { rules: recommendedRules } }
+};
+//#endregion
+export { src_default as default };

package/dist/oxlint-plugin-cell-vocabulary.d.ts

@@ -0,0 +1,20 @@
+import { Rule } from '@oxlint/plugins';
+
+declare const _default: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        'no-io-in-phase-bodies': Rule;
+    };
+    configs: {
+        recommended: {
+            rules: {
+                readonly [x: string]: "error";
+            };
+        };
+    };
+};
+export default _default;
+
+export { }

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@systemfsoftware/oxlint-plugin-cell-vocabulary",
+  "license": "Apache-2.0",
+  "version": "1.0.0",
+  "author": "Ryan Lee <drdgvhbh@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/systemfsoftware/systemfsoftware.git",
+    "directory": "packages/oxlint-plugins/cell-vocabulary"
+  },
+  "homepage": "https://github.com/systemfsoftware/systemfsoftware/tree/main/packages/oxlint-plugins/cell-vocabulary#readme",
+  "bugs": "https://github.com/systemfsoftware/systemfsoftware/issues",
+  "description": "Oxlint rules that decide the phase purity and I/O-cell vocabulary of a Cell description by walking Cell.vocabulary, and report I/O reached from the body of a phase whose kind forbids it.",
+  "keywords": [
+    "oxlint",
+    "oxlint-plugin",
+    "oxc",
+    "lint",
+    "linter",
+    "lint-rules",
+    "effect",
+    "effect-ts",
+    "cell",
+    "description",
+    "vocabulary",
+    "typescript"
+  ],
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/oxlint-plugin-cell-vocabulary.d.ts",
+      "default": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@oxc-project/types": "^0.140.0",
+    "@oxlint/plugins": "^1.77.0",
+    "@systemfsoftware/effect-cell-types": "^1.0.1"
+  },
+  "devDependencies": {
+    "@microsoft/api-extractor": "^7.58.7",
+    "@systemfsoftware/arethetypeswrong-cli": "^1.1.1",
+    "@types/node": "^24",
+    "@vitest/coverage-v8": "^4",
+    "effect": "4.0.0-rc.108",
+    "oxlint": "^1.77.0",
+    "rimraf": "^6.1.3",
+    "tsdown": "^0.22.14",
+    "typescript": "^7",
+    "vitest": "^4.1.10",
+    "@systemfsoftware/tsconfig": "^1.3.1",
+    "@systemfsoftware/vitest-config": "^0.1.0"
+  },
+  "peerDependencies": {
+    "effect": "4.0.0-rc.108",
+    "typescript": ">=5.0.0"
+  },
+  "publishConfig": {
+    "provenance": true
+  },
+  "scripts": {
+    "build": "tsdown && pnpm api:check",
+    "clean": "rimraf dist",
+    "typecheck": "tsc --noEmit --incremental",
+    "test": "vitest run",
+    "test:run": "vitest run --coverage",
+    "mutation": "stryker run",
+    "mutation:full": "stryker run --force",
+    "lint": "f=${OXLINT_FORMAT:-${AGENT:+agent}}; oxlint . --format=${f:-default}",
+    "attw": "attw --pack .",
+    "api:check": "api-extractor run",
+    "api:update": "api-extractor run --local"
+  }
+}