@systemfsoftware/stryker-js-instrumenter 5.0.2 → 6.0.1

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @systemfsoftware/stryker-js-instrumenter
 
+## 6.0.1
+
+### Patch Changes
+
+- Imports rewired to the collapsed `@systemfsoftware/stryker-js` root entry; each package now co-releases against the root-entry major.
+
+- Updated dependencies:
+  - @systemfsoftware/effect-cell-types@8.0.0
+  - @systemfsoftware/stryker-js@4.0.0
+
+## 6.0.0
+
+### Major Changes
+
+- Nothing a consumer can observe moved in the four packages above, so no release is warranted.
+
+  `@systemfsoftware/stryker-js-instrumenter` now answers with promises: `transform` and `placeHeader` return `Promise`, and `AstTransformer` is a promise-returning function type. Await them where you call them. The parser is read on first use rather than at import, so importing this package no longer constructs Node's WebAssembly runtime, and `ExperimentalWarning: WASI` no longer appears until something is actually parsed.
+
+### Patch Changes
+
+- Releases the workspace so its published versions track the shared dependency graph this change moves.
+
+- The `@systemfsoftware/source` export condition is gone. It resolved to a package's TypeScript sources for editors and in-repo typechecks; each package now exports only its built entry. If your tsconfig sets `customConditions: ["@systemfsoftware/source"]`, or a bundler config names that condition, remove it — resolution falls back to the built entry, which is what every consumer already got.
+
 ## 5.0.2
 
 ### Patch Changes

package/dist/index.d.mts

@@ -1,59 +1,68 @@
-import { FileDescription, Mutant } from "@systemfsoftware/stryker-js/Mutant";
-import * as Effect from "effect/Effect";
-import * as S from "effect/Schema";
-import "effect/Option";
-import { IgnorerService } from "@systemfsoftware/stryker-js/Ignorer";
-//#region src/Instrument.schema.d.ts
-declare const InstrumentError_base: S.Class<InstrumentError, S.TaggedStruct<"InstrumentError", {
-  readonly message: S.String;
-  readonly cause: S.Defect;
-}>, import("effect/Cause").YieldableError>;
-declare class InstrumentError extends InstrumentError_base {
-  get message(): string;
-}
-declare const InstrumenterOptionsSchema: S.Struct<{
-  readonly excludedMutations: S.$Array<S.String>;
-  readonly ignorers: S.$Array<S.Unknown>;
-  readonly noHeader: S.optional<S.Boolean>;
-}>;
-type InstrumenterOptions = typeof InstrumenterOptionsSchema.Type;
-declare const InstrumentResult_base: S.Class<InstrumentResult$1, S.TaggedStruct<"InstrumentResult", {
-  readonly files: S.$Array<S.Struct<{
-    readonly name: S.String;
-    readonly content: S.String;
-    readonly mutate: S.Union<readonly [S.Boolean, S.$Array<S.Struct<{
-      readonly start: S.Struct<{
-        readonly line: S.Finite;
-        readonly column: S.Finite;
-      }>;
-      readonly end: S.Struct<{
-        readonly line: S.Finite;
-        readonly column: S.Finite;
-      }>;
-    }>>]>;
-  }>>;
-  readonly mutants: S.$Array<typeof Mutant>;
-}>, {}>;
-declare class InstrumentResult$1 extends InstrumentResult_base {}
-//#endregion
-//#region src/Instrument.d.ts
-interface File extends FileDescription {
-  name: string;
-  content: string;
-}
-interface InstrumentResult {
-  files: readonly File[];
-  mutants: readonly Mutant[];
-}
-declare function disableTypeChecks(file: File): Promise<File>;
-declare const instrument: (files: readonly File[], options: InstrumenterOptions) => Effect.Effect<InstrumentResult$1, InstrumentError>;
-//#endregion
-//#region src/Parser.d.ts
-interface ParserOptions {}
-//#endregion
-//#region src/Transformer.d.ts
-declare const angularIgnorer: IgnorerService;
-declare const strykerPlugins: readonly unknown[];
-declare const frameworkPluginsFileUrl: string;
-//#endregion
-export { type File, type InstrumentResult, type InstrumenterOptions, type ParserOptions, angularIgnorer, disableTypeChecks, frameworkPluginsFileUrl, instrument, strykerPlugins };
+import * as Effect from 'effect/Effect';
+import { FileDescription } from '@systemfsoftware/stryker-js';
+import { IgnorerService } from '@systemfsoftware/stryker-js';
+import { Mutant } from '@systemfsoftware/stryker-js';
+import * as S from 'effect/Schema';
+import { YieldableError } from 'effect/Cause';
+
+export declare const angularIgnorer: IgnorerService;
+
+export declare function disableTypeChecks(file: File_2): Promise<File_2>;
+
+declare interface File_2 extends FileDescription {
+    name: string;
+    content: string;
+}
+export { File_2 as File }
+
+export declare const frameworkPluginsFileUrl: string;
+
+export declare const instrument: (files: readonly File_2[], options: InstrumenterOptions) => Effect.Effect<InstrumentResult$1, InstrumentError>;
+
+export declare type InstrumenterOptions = typeof InstrumenterOptionsSchema.Type;
+
+declare const InstrumenterOptionsSchema: S.Struct<{
+    readonly excludedMutations: S.$Array<S.String>;
+    readonly ignorers: S.$Array<S.Unknown>;
+    readonly noHeader: S.optional<S.Boolean>;
+}>;
+
+declare class InstrumentError extends InstrumentError_base {
+    get message(): string;
+}
+
+declare const InstrumentError_base: S.Class<InstrumentError, S.TaggedStruct<"InstrumentError", {
+    readonly message: S.String;
+    readonly cause: S.Defect;
+}>, YieldableError>;
+
+declare class InstrumentResult$1 extends InstrumentResult_base {}
+
+export declare interface InstrumentResult {
+    files: readonly File_2[];
+    mutants: readonly Mutant[];
+}
+
+declare const InstrumentResult_base: S.Class<InstrumentResult$1, S.TaggedStruct<"InstrumentResult", {
+    readonly files: S.$Array<S.Struct<{
+        readonly name: S.String;
+        readonly content: S.String;
+        readonly mutate: S.Union<readonly [S.Boolean, S.$Array<S.Struct<{
+            readonly start: S.Struct<{
+                readonly line: S.Finite;
+                readonly column: S.Finite;
+            }>;
+            readonly end: S.Struct<{
+                readonly line: S.Finite;
+                readonly column: S.Finite;
+            }>;
+        }>>]>;
+    }>>;
+    readonly mutants: S.$Array<typeof Mutant>;
+}>, {}>;
+
+export declare interface ParserOptions {}
+
+export declare const strykerPlugins: readonly unknown[];
+
+export { }

package/dist/index.mjs

@@ -1,14 +1,11 @@
-import { INSTRUMENTER_CONSTANTS, Mutant } from "@systemfsoftware/stryker-js/Mutant";
+import { INSTRUMENTER_CONSTANTS, Mutant, propertyPath, strykerReportBugUrl } from "@systemfsoftware/stryker-js";
 import * as Effect from "effect/Effect";
 import * as Predicate from "effect/Predicate";
 import * as S from "effect/Schema";
 import * as Arr from "effect/Array";
 import * as Match from "effect/Match";
 import * as Option from "effect/Option";
-import { parseSync } from "oxc-parser";
 import path from "path";
-import "@systemfsoftware/stryker-js/Ignorer";
-import { propertyPath, strykerReportBugUrl } from "@systemfsoftware/stryker-js/Schema";
 import path$1 from "node:path";
 import { RegExpParser, visitRegExpAST } from "@eslint-community/regexpp";
 //#region src/Instrument.schema.ts
@@ -641,6 +638,13 @@ function isIndexedList(container, index) {
 	return isNodeList(container) && Number.isInteger(index);
 }
 //#endregion
+//#region src/Oxc.ts
+let oxc;
+const loadOxc = async () => {
+	if (oxc === void 0) oxc = await import("oxc-parser");
+	return oxc;
+};
+//#endregion
 //#region src/Parser.schema.ts
 var ParseFailed = class extends S.TaggedError("@systemfsoftware/stryker-js-instrumenter/ParseFailed")("ParseFailed", {
 	fileName: S.String,
@@ -723,7 +727,8 @@ function fieldOf(value, key) {
 function appendIfDefined(values, value) {
 	if (value !== void 0) values.push(value);
 }
-function parseWithOxc(text, fileName, lang) {
+async function parseWithOxc(text, fileName, lang) {
+	const { parseSync } = await loadOxc();
 	const result = parseSync(fileName, text, {
 		lang,
 		range: true
@@ -795,7 +800,7 @@ function getFormat(fileName, override) {
 }
 function createJSParser() {
 	return async function parse(text, fileName) {
-		const { root, comments } = parseWithOxc(text, fileName, "js");
+		const { root, comments } = await parseWithOxc(text, fileName, "js");
 		return {
 			originFileName: fileName,
 			rawContent: text,
@@ -806,7 +811,7 @@ function createJSParser() {
 	};
 }
 async function parseTS(text, fileName) {
-	const { root, comments } = parseWithOxc(text, fileName, "ts");
+	const { root, comments } = await parseWithOxc(text, fileName, "ts");
 	return {
 		originFileName: fileName,
 		rawContent: text,
@@ -816,7 +821,7 @@ async function parseTS(text, fileName) {
 	};
 }
 async function parseTsx(text, fileName) {
-	const { root, comments } = parseWithOxc(text, fileName, "tsx");
+	const { root, comments } = await parseWithOxc(text, fileName, "tsx");
 	return {
 		root,
 		comments,
@@ -4794,7 +4799,7 @@ function isPropertyBearing(node) {
 }
 const strykerPlugins = [];
 const frameworkPluginsFileUrl = import.meta.url;
-const parsedInstrumentationHeader = parseSync("instrumenter-header.js", `// @ts-nocheck
+const INSTRUMENTATION_HEADER_SOURCE = `// @ts-nocheck
 var ${STRYKER_NAMESPACE_HELPER} = function(){
   var g = typeof globalThis === 'object' && globalThis && globalThis.Math === Math && globalThis || new Function("return this")();
   var ns = g.${INSTRUMENTER_CONSTANTS.NAMESPACE} || (g.${INSTRUMENTER_CONSTANTS.NAMESPACE} = {});
@@ -4838,34 +4843,37 @@ var ${IS_MUTANT_ACTIVE_HELPER} = function(id) {
   }
   ${IS_MUTANT_ACTIVE_HELPER} = isActive;
   return isActive(id);
-}`, {
-	lang: "js",
-	range: true
-});
-if (parsedInstrumentationHeader.errors.length > 0) throw new Error("Instrumentation header failed to parse");
-const instrumentationHeader = parsedInstrumentationHeader.program.body;
-deepFreeze(instrumentationHeader);
-function placeHeaderIfNeeded(mutantCollector, originFileName, options, root) {
-	if (shouldPlaceHeader(mutantCollector, originFileName, options)) placeHeader(root);
+}`;
+let instrumentationHeaderValue;
+const instrumentationHeader = async () => {
+	if (instrumentationHeaderValue === void 0) {
+		instrumentationHeaderValue = (await parseWithOxc(INSTRUMENTATION_HEADER_SOURCE, "instrumenter-header.js", "js")).root.body;
+		deepFreeze(instrumentationHeaderValue);
+	}
+	return instrumentationHeaderValue;
+};
+async function placeHeaderIfNeeded(mutantCollector, originFileName, options, root) {
+	if (shouldPlaceHeader(mutantCollector, originFileName, options)) await placeHeader(root);
 }
 function shouldPlaceHeader(mutantCollector, originFileName, options) {
 	return hasPlacedMutants(mutantCollector, originFileName) && options.noHeader !== true;
 }
-function placeHeader(root) {
-	root.body.unshift(...headerFor(root));
+async function placeHeader(root) {
+	root.body.unshift(...await headerFor(root));
 }
-function headerFor(root) {
+async function headerFor(root) {
+	const header = await instrumentationHeader();
 	return Option.match(leadingCommentsOf(root), {
-		onNone: () => instrumentationHeader,
-		onSome: (leadingComments) => [commentedHeader(leadingComments), ...instrumentationHeader.slice(1)]
+		onNone: () => header,
+		onSome: (leadingComments) => [commentedHeader(leadingComments, header), ...header.slice(1)]
 	});
 }
 function leadingCommentsOf(root) {
 	const firstStatement = root.body[0];
 	return Option.filter(Option.fromNullishOr(firstStatement?.leadingComments), isUnknownArray);
 }
-function commentedHeader(leadingComments) {
-	const cloned = cloneNode(Option.getOrThrowWith(Option.fromNullishOr(instrumentationHeader[0]), () => /* @__PURE__ */ new Error("Instrumentation header is empty")));
+function commentedHeader(leadingComments, header) {
+	const cloned = cloneNode(Option.getOrThrowWith(Option.fromNullishOr(header[0]), () => /* @__PURE__ */ new Error("Instrumentation header is empty")));
 	cloned.leadingComments = leadingComments;
 	return cloned;
 }
@@ -4905,7 +4913,7 @@ function isMap(value) {
 function isSet(value) {
 	return value instanceof Set;
 }
-function transform(ast, mutantCollector, transformerContext) {
+async function transform(ast, mutantCollector, transformerContext) {
 	const context = {
 		...transformerContext,
 		transform
@@ -4918,34 +4926,31 @@ function transform(ast, mutantCollector, transformerContext) {
 		case "svelte": return transformSvelte(ast, mutantCollector, context);
 	}
 }
-const transformHtml = ({ root }, mutantCollector, context) => {
+const transformHtml = async ({ root }, mutantCollector, context) => {
 	const warnings = [];
-	root.scripts.forEach((ast) => {
-		warnings.push(...context.transform(ast, mutantCollector, context));
-	});
+	for (const script of root.scripts) warnings.push(...await context.transform(script, mutantCollector, context));
 	return warnings;
 };
 const moduleScript = `<script context="module">
 \n<\/script>\n`;
-const transformSvelte = (svelte, mutantCollector, context) => {
+const transformSvelte = async (svelte, mutantCollector, context) => {
 	const warnings = [];
 	const { root } = svelte;
-	[root.moduleScript, ...root.additionalScripts].filter(Predicate.isNotNullish).forEach((script) => {
-		warnings.push(...context.transform(script.ast, mutantCollector, {
-			...context,
-			options: {
-				...context.options,
-				noHeader: true
-			}
-		}));
-	});
-	placeModuleHeaderIfNeeded(svelte, mutantCollector);
+	const scripts = [root.moduleScript, ...root.additionalScripts].filter(Predicate.isNotNullish);
+	for (const script of scripts) warnings.push(...await context.transform(script.ast, mutantCollector, {
+		...context,
+		options: {
+			...context.options,
+			noHeader: true
+		}
+	}));
+	await placeModuleHeaderIfNeeded(svelte, mutantCollector);
 	return warnings;
 };
-function placeModuleHeaderIfNeeded(svelte, mutantCollector) {
-	if (hasPlacedMutants(mutantCollector, svelte.originFileName)) placeModuleHeader(svelte);
+async function placeModuleHeaderIfNeeded(svelte, mutantCollector) {
+	if (hasPlacedMutants(mutantCollector, svelte.originFileName)) await placeModuleHeader(svelte);
 }
-function placeModuleHeader(svelte) {
+async function placeModuleHeader(svelte) {
 	const { root, originFileName } = svelte;
 	if (!root.moduleScript) {
 		root.moduleScript = {
@@ -4968,7 +4973,7 @@ function placeModuleHeader(svelte) {
 			script.range.end += moduleScript.length;
 		});
 	}
-	placeHeader(root.moduleScript.ast.root);
+	await placeHeader(root.moduleScript.ast.root);
 }
 function emptyProgram() {
 	return {
@@ -4980,7 +4985,7 @@ function emptyProgram() {
 function isMutateRangeList(value) {
 	return Array.isArray(value);
 }
-const transformScript = ({ root, originFileName, rawContent, offset, comments }, mutantCollector, { options, mutateDescription }, mutators, mutantPlacers) => {
+const transformScript = async ({ root, originFileName, rawContent, offset, comments }, mutantCollector, { options, mutateDescription }, mutators, mutantPlacers) => {
 	const lineTable = buildLineTable(rawContent);
 	attachComments(root, comments, lineTable);
 	const placementMap = /* @__PURE__ */ new Map();
@@ -5001,7 +5006,7 @@ const transformScript = ({ root, originFileName, rawContent, offset, comments },
 			if (hasAppliedMutants(placement)) applyPlacement(path, placement);
 		}
 	});
-	placeHeaderIfNeeded(mutantCollector, originFileName, options, root);
+	await placeHeaderIfNeeded(mutantCollector, originFileName, options, root);
 	return warnings;
 	function visitNode(path) {
 		if (shouldSkip(path)) {
@@ -5303,7 +5308,7 @@ const readCollected = (command) => Effect.gen(function* () {
 		ast
 	})));
 	const collector = createMutantCollector();
-	yield* Effect.forEach(parsed, ({ file, ast }) => Effect.try({
+	yield* Effect.forEach(parsed, ({ file, ast }) => Effect.tryPromise({
 		try: () => transform(ast, collector, {
 			options: toTransformerOptions(options),
 			mutateDescription: toOneBasedLineNumber(file.mutate)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@systemfsoftware/stryker-js-instrumenter",
-  "version": "5.0.2",
+  "version": "6.0.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/systemfsoftware/systemfsoftware.git",
@@ -24,11 +24,12 @@
     "angular-html-parser": "~10.4.0",
     "effect": "4.0.0-rc.112",
     "oxc-parser": "^0.140.0",
-    "@systemfsoftware/effect-cell-types": "^7.0.0",
-    "@systemfsoftware/stryker-js": "^3.0.1"
+    "@systemfsoftware/effect-cell-types": "^8.0.0",
+    "@systemfsoftware/stryker-js": "^4.0.0"
   },
   "devDependencies": {
-    "@systemfsoftware/arethetypeswrong-cli": "^1.1.1",
+    "@microsoft/api-extractor": "^7.58.7",
+    "@systemfsoftware/arethetypeswrong-cli": "^4.1.0",
     "@types/estree": "1.0.8",
     "@types/node": "^24",
     "oxlint": "^1.77.0",
@@ -37,11 +38,11 @@
     "tsdown": "^0.22.14",
     "typescript": "^7",
     "vitest": "^4",
-    "@systemfsoftware/all": "^2.0.0",
-    "@systemfsoftware/effect-gherkin-spec": "^4.0.1",
+    "@systemfsoftware/all": "^2.0.2",
+    "@systemfsoftware/effect-gherkin-spec": "^4.0.2",
+    "@systemfsoftware/vitest-config": "^0.1.0",
     "@systemfsoftware/oxlint-config": "^0.1.0",
-    "@systemfsoftware/tsconfig": "^1.3.3",
-    "@systemfsoftware/vitest-config": "^0.1.0"
+    "@systemfsoftware/tsconfig": "^1.3.4"
   },
   "engines": {
     "node": ">=20.0.0"
@@ -59,10 +60,12 @@
   },
   "scripts": {
     "clean": "rimraf dist",
-    "build": "tsdown",
+    "build": "tsdown && pnpm api:check",
     "typecheck": "tsc --noEmit --incremental",
     "attw": "attw --pack .",
     "test": "vitest run",
-    "lint": "f=${OXLINT_FORMAT:-${AGENT:+agent}}; oxlint . --format=${f:-default}"
+    "lint": "f=${OXLINT_FORMAT:-${AGENT:+agent}}; oxlint . --format=${f:-default}",
+    "api:check": "tsdown && api-extractor run",
+    "api:update": "api-extractor run --local"
   }
 }