unplugin-atscript 0.1.91 → 0.1.92

package/README.md

@@ -58,6 +58,7 @@ Vite picks the root up automatically (from `configResolved`); other bundlers nee
 - Strict validation — build fails on `.as` errors by default (`strict: false` to disable)
 - Tree-shaking aware — marks non-mutating modules as side-effect-free
 - On Vite, prebundles `@atscript/typescript/utils` so the first `.as`-backed route does not trigger a dep re-optimization reload
+- Watch-safe in dev — a changed `.as` file is dropped from the document cache and every transitive `.as` import is registered as a watch file, so dependants are re-checked against the new definition on the next reload (esbuild excepted: unplugin has no `watchChange` for it, so under esbuild watch a changed `.as` import still needs a restart)
 
 ## Documentation
 

package/dist/esbuild.cjs

@@ -36,6 +36,26 @@ let _atscript_typescript = require("@atscript/typescript");
 //#region packages/unplugin/src/index.ts
 const RE_DTS = /\.d\.[cm]?ts$/;
 const RUNTIME_ENTRY = "@atscript/typescript/utils";
+/**
+* Registers every transitive `.as` dependency of `doc` as a watch file.
+*
+* The bundler's module graph only knows the imports the rendered output keeps:
+* the JS renderer drops imports it does not use, and the dts graph and
+* non-Vite watchers never see the JS import list at all. Watching the whole
+* `.as` closure explicitly makes the bundler re-run `load` for the importer
+* whenever any of them changes.
+*
+* Re-registering on every `load` is required: Vite replaces a module's watch
+* edges on each transform, so a repeat registration is deduped while skipping
+* it would prune the edge.
+*/ function addTransitiveWatchFiles(ctx, doc, visited = new Set([doc])) {
+	for (const dep of doc.dependencies) {
+		if (visited.has(dep)) continue;
+		visited.add(dep);
+		ctx.addWatchFile((0, _atscript_core.fileUriToPath)(dep.id));
+		addTransitiveWatchFiles(ctx, dep, visited);
+	}
+}
 function isResolvableFrom(specifier, from) {
 	try {
 		(0, module$1.createRequire)(path.default.join(from, "package.json")).resolve(specifier);
@@ -87,6 +107,7 @@ const unpluginFactory = (opts) => {
 				const code = (await (0, fs_promises.readFile)(sourceId, "utf8")).toString();
 				const doc = await repo.openDocument(`file://${sourceId}`, code);
 				await repo.checkDoc(doc);
+				addTransitiveWatchFiles(this, doc);
 				const messages = doc.getDiagMessages().reverse();
 				let error = "";
 				for (const m of messages) if (m.severity === 1) {
@@ -107,6 +128,10 @@ const unpluginFactory = (opts) => {
 					moduleSideEffects: hasMutatingAnnotates ? void 0 : false
 				};
 			}
+		},
+		watchChange(id) {
+			if (!repo || !id.endsWith(".as")) return;
+			repo.closeDocument(`file://${id}`);
 		}
 	};
 };

package/dist/esbuild.mjs

@@ -2,12 +2,32 @@ import { createEsbuildPlugin } from "unplugin";
 import { readFile } from "fs/promises";
 import { createRequire } from "module";
 import path from "path";
-import { AtscriptRepo, isAnnotate, loadConfig, resolveConfigFile } from "@atscript/core";
+import { AtscriptRepo, fileUriToPath, isAnnotate, loadConfig, resolveConfigFile } from "@atscript/core";
 import { tsPlugin } from "@atscript/typescript";
 
 //#region packages/unplugin/src/index.ts
 const RE_DTS = /\.d\.[cm]?ts$/;
 const RUNTIME_ENTRY = "@atscript/typescript/utils";
+/**
+* Registers every transitive `.as` dependency of `doc` as a watch file.
+*
+* The bundler's module graph only knows the imports the rendered output keeps:
+* the JS renderer drops imports it does not use, and the dts graph and
+* non-Vite watchers never see the JS import list at all. Watching the whole
+* `.as` closure explicitly makes the bundler re-run `load` for the importer
+* whenever any of them changes.
+*
+* Re-registering on every `load` is required: Vite replaces a module's watch
+* edges on each transform, so a repeat registration is deduped while skipping
+* it would prune the edge.
+*/ function addTransitiveWatchFiles(ctx, doc, visited = new Set([doc])) {
+	for (const dep of doc.dependencies) {
+		if (visited.has(dep)) continue;
+		visited.add(dep);
+		ctx.addWatchFile(fileUriToPath(dep.id));
+		addTransitiveWatchFiles(ctx, dep, visited);
+	}
+}
 function isResolvableFrom(specifier, from) {
 	try {
 		createRequire(path.join(from, "package.json")).resolve(specifier);
@@ -59,6 +79,7 @@ const unpluginFactory = (opts) => {
 				const code = (await readFile(sourceId, "utf8")).toString();
 				const doc = await repo.openDocument(`file://${sourceId}`, code);
 				await repo.checkDoc(doc);
+				addTransitiveWatchFiles(this, doc);
 				const messages = doc.getDiagMessages().reverse();
 				let error = "";
 				for (const m of messages) if (m.severity === 1) {
@@ -79,6 +100,10 @@ const unpluginFactory = (opts) => {
 					moduleSideEffects: hasMutatingAnnotates ? void 0 : false
 				};
 			}
+		},
+		watchChange(id) {
+			if (!repo || !id.endsWith(".as")) return;
+			repo.closeDocument(`file://${id}`);
 		}
 	};
 };

package/dist/farm.cjs

@@ -36,6 +36,26 @@ let _atscript_typescript = require("@atscript/typescript");
 //#region packages/unplugin/src/index.ts
 const RE_DTS = /\.d\.[cm]?ts$/;
 const RUNTIME_ENTRY = "@atscript/typescript/utils";
+/**
+* Registers every transitive `.as` dependency of `doc` as a watch file.
+*
+* The bundler's module graph only knows the imports the rendered output keeps:
+* the JS renderer drops imports it does not use, and the dts graph and
+* non-Vite watchers never see the JS import list at all. Watching the whole
+* `.as` closure explicitly makes the bundler re-run `load` for the importer
+* whenever any of them changes.
+*
+* Re-registering on every `load` is required: Vite replaces a module's watch
+* edges on each transform, so a repeat registration is deduped while skipping
+* it would prune the edge.
+*/ function addTransitiveWatchFiles(ctx, doc, visited = new Set([doc])) {
+	for (const dep of doc.dependencies) {
+		if (visited.has(dep)) continue;
+		visited.add(dep);
+		ctx.addWatchFile((0, _atscript_core.fileUriToPath)(dep.id));
+		addTransitiveWatchFiles(ctx, dep, visited);
+	}
+}
 function isResolvableFrom(specifier, from) {
 	try {
 		(0, module$1.createRequire)(path.default.join(from, "package.json")).resolve(specifier);
@@ -87,6 +107,7 @@ const unpluginFactory = (opts) => {
 				const code = (await (0, fs_promises.readFile)(sourceId, "utf8")).toString();
 				const doc = await repo.openDocument(`file://${sourceId}`, code);
 				await repo.checkDoc(doc);
+				addTransitiveWatchFiles(this, doc);
 				const messages = doc.getDiagMessages().reverse();
 				let error = "";
 				for (const m of messages) if (m.severity === 1) {
@@ -107,6 +128,10 @@ const unpluginFactory = (opts) => {
 					moduleSideEffects: hasMutatingAnnotates ? void 0 : false
 				};
 			}
+		},
+		watchChange(id) {
+			if (!repo || !id.endsWith(".as")) return;
+			repo.closeDocument(`file://${id}`);
 		}
 	};
 };

package/dist/farm.mjs

@@ -2,12 +2,32 @@ import { createFarmPlugin } from "unplugin";
 import { readFile } from "fs/promises";
 import { createRequire } from "module";
 import path from "path";
-import { AtscriptRepo, isAnnotate, loadConfig, resolveConfigFile } from "@atscript/core";
+import { AtscriptRepo, fileUriToPath, isAnnotate, loadConfig, resolveConfigFile } from "@atscript/core";
 import { tsPlugin } from "@atscript/typescript";
 
 //#region packages/unplugin/src/index.ts
 const RE_DTS = /\.d\.[cm]?ts$/;
 const RUNTIME_ENTRY = "@atscript/typescript/utils";
+/**
+* Registers every transitive `.as` dependency of `doc` as a watch file.
+*
+* The bundler's module graph only knows the imports the rendered output keeps:
+* the JS renderer drops imports it does not use, and the dts graph and
+* non-Vite watchers never see the JS import list at all. Watching the whole
+* `.as` closure explicitly makes the bundler re-run `load` for the importer
+* whenever any of them changes.
+*
+* Re-registering on every `load` is required: Vite replaces a module's watch
+* edges on each transform, so a repeat registration is deduped while skipping
+* it would prune the edge.
+*/ function addTransitiveWatchFiles(ctx, doc, visited = new Set([doc])) {
+	for (const dep of doc.dependencies) {
+		if (visited.has(dep)) continue;
+		visited.add(dep);
+		ctx.addWatchFile(fileUriToPath(dep.id));
+		addTransitiveWatchFiles(ctx, dep, visited);
+	}
+}
 function isResolvableFrom(specifier, from) {
 	try {
 		createRequire(path.join(from, "package.json")).resolve(specifier);
@@ -59,6 +79,7 @@ const unpluginFactory = (opts) => {
 				const code = (await readFile(sourceId, "utf8")).toString();
 				const doc = await repo.openDocument(`file://${sourceId}`, code);
 				await repo.checkDoc(doc);
+				addTransitiveWatchFiles(this, doc);
 				const messages = doc.getDiagMessages().reverse();
 				let error = "";
 				for (const m of messages) if (m.severity === 1) {
@@ -79,6 +100,10 @@ const unpluginFactory = (opts) => {
 					moduleSideEffects: hasMutatingAnnotates ? void 0 : false
 				};
 			}
+		},
+		watchChange(id) {
+			if (!repo || !id.endsWith(".as")) return;
+			repo.closeDocument(`file://${id}`);
 		}
 	};
 };

package/dist/index.cjs

@@ -37,6 +37,26 @@ let unplugin = require("unplugin");
 //#region packages/unplugin/src/index.ts
 const RE_DTS = /\.d\.[cm]?ts$/;
 const RUNTIME_ENTRY = "@atscript/typescript/utils";
+/**
+* Registers every transitive `.as` dependency of `doc` as a watch file.
+*
+* The bundler's module graph only knows the imports the rendered output keeps:
+* the JS renderer drops imports it does not use, and the dts graph and
+* non-Vite watchers never see the JS import list at all. Watching the whole
+* `.as` closure explicitly makes the bundler re-run `load` for the importer
+* whenever any of them changes.
+*
+* Re-registering on every `load` is required: Vite replaces a module's watch
+* edges on each transform, so a repeat registration is deduped while skipping
+* it would prune the edge.
+*/ function addTransitiveWatchFiles(ctx, doc, visited = new Set([doc])) {
+	for (const dep of doc.dependencies) {
+		if (visited.has(dep)) continue;
+		visited.add(dep);
+		ctx.addWatchFile((0, _atscript_core.fileUriToPath)(dep.id));
+		addTransitiveWatchFiles(ctx, dep, visited);
+	}
+}
 function isResolvableFrom(specifier, from) {
 	try {
 		(0, module$1.createRequire)(path.default.join(from, "package.json")).resolve(specifier);
@@ -88,6 +108,7 @@ const unpluginFactory = (opts) => {
 				const code = (await (0, fs_promises.readFile)(sourceId, "utf8")).toString();
 				const doc = await repo.openDocument(`file://${sourceId}`, code);
 				await repo.checkDoc(doc);
+				addTransitiveWatchFiles(this, doc);
 				const messages = doc.getDiagMessages().reverse();
 				let error = "";
 				for (const m of messages) if (m.severity === 1) {
@@ -108,6 +129,10 @@ const unpluginFactory = (opts) => {
 					moduleSideEffects: hasMutatingAnnotates ? void 0 : false
 				};
 			}
+		},
+		watchChange(id) {
+			if (!repo || !id.endsWith(".as")) return;
+			repo.closeDocument(`file://${id}`);
 		}
 	};
 };

package/dist/index.mjs

@@ -1,13 +1,33 @@
 import { readFile } from "fs/promises";
 import { createRequire } from "module";
 import path from "path";
-import { AtscriptRepo, isAnnotate, loadConfig, resolveConfigFile } from "@atscript/core";
+import { AtscriptRepo, fileUriToPath, isAnnotate, loadConfig, resolveConfigFile } from "@atscript/core";
 import { tsPlugin } from "@atscript/typescript";
 import { createUnplugin } from "unplugin";
 
 //#region packages/unplugin/src/index.ts
 const RE_DTS = /\.d\.[cm]?ts$/;
 const RUNTIME_ENTRY = "@atscript/typescript/utils";
+/**
+* Registers every transitive `.as` dependency of `doc` as a watch file.
+*
+* The bundler's module graph only knows the imports the rendered output keeps:
+* the JS renderer drops imports it does not use, and the dts graph and
+* non-Vite watchers never see the JS import list at all. Watching the whole
+* `.as` closure explicitly makes the bundler re-run `load` for the importer
+* whenever any of them changes.
+*
+* Re-registering on every `load` is required: Vite replaces a module's watch
+* edges on each transform, so a repeat registration is deduped while skipping
+* it would prune the edge.
+*/ function addTransitiveWatchFiles(ctx, doc, visited = new Set([doc])) {
+	for (const dep of doc.dependencies) {
+		if (visited.has(dep)) continue;
+		visited.add(dep);
+		ctx.addWatchFile(fileUriToPath(dep.id));
+		addTransitiveWatchFiles(ctx, dep, visited);
+	}
+}
 function isResolvableFrom(specifier, from) {
 	try {
 		createRequire(path.join(from, "package.json")).resolve(specifier);
@@ -59,6 +79,7 @@ const unpluginFactory = (opts) => {
 				const code = (await readFile(sourceId, "utf8")).toString();
 				const doc = await repo.openDocument(`file://${sourceId}`, code);
 				await repo.checkDoc(doc);
+				addTransitiveWatchFiles(this, doc);
 				const messages = doc.getDiagMessages().reverse();
 				let error = "";
 				for (const m of messages) if (m.severity === 1) {
@@ -79,6 +100,10 @@ const unpluginFactory = (opts) => {
 					moduleSideEffects: hasMutatingAnnotates ? void 0 : false
 				};
 			}
+		},
+		watchChange(id) {
+			if (!repo || !id.endsWith(".as")) return;
+			repo.closeDocument(`file://${id}`);
 		}
 	};
 };

package/dist/rolldown.cjs

@@ -36,6 +36,26 @@ let _atscript_typescript = require("@atscript/typescript");
 //#region packages/unplugin/src/index.ts
 const RE_DTS = /\.d\.[cm]?ts$/;
 const RUNTIME_ENTRY = "@atscript/typescript/utils";
+/**
+* Registers every transitive `.as` dependency of `doc` as a watch file.
+*
+* The bundler's module graph only knows the imports the rendered output keeps:
+* the JS renderer drops imports it does not use, and the dts graph and
+* non-Vite watchers never see the JS import list at all. Watching the whole
+* `.as` closure explicitly makes the bundler re-run `load` for the importer
+* whenever any of them changes.
+*
+* Re-registering on every `load` is required: Vite replaces a module's watch
+* edges on each transform, so a repeat registration is deduped while skipping
+* it would prune the edge.
+*/ function addTransitiveWatchFiles(ctx, doc, visited = new Set([doc])) {
+	for (const dep of doc.dependencies) {
+		if (visited.has(dep)) continue;
+		visited.add(dep);
+		ctx.addWatchFile((0, _atscript_core.fileUriToPath)(dep.id));
+		addTransitiveWatchFiles(ctx, dep, visited);
+	}
+}
 function isResolvableFrom(specifier, from) {
 	try {
 		(0, module$1.createRequire)(path.default.join(from, "package.json")).resolve(specifier);
@@ -87,6 +107,7 @@ const unpluginFactory = (opts) => {
 				const code = (await (0, fs_promises.readFile)(sourceId, "utf8")).toString();
 				const doc = await repo.openDocument(`file://${sourceId}`, code);
 				await repo.checkDoc(doc);
+				addTransitiveWatchFiles(this, doc);
 				const messages = doc.getDiagMessages().reverse();
 				let error = "";
 				for (const m of messages) if (m.severity === 1) {
@@ -107,6 +128,10 @@ const unpluginFactory = (opts) => {
 					moduleSideEffects: hasMutatingAnnotates ? void 0 : false
 				};
 			}
+		},
+		watchChange(id) {
+			if (!repo || !id.endsWith(".as")) return;
+			repo.closeDocument(`file://${id}`);
 		}
 	};
 };

package/dist/rolldown.mjs

@@ -2,12 +2,32 @@ import { createRolldownPlugin } from "unplugin";
 import { readFile } from "fs/promises";
 import { createRequire } from "module";
 import path from "path";
-import { AtscriptRepo, isAnnotate, loadConfig, resolveConfigFile } from "@atscript/core";
+import { AtscriptRepo, fileUriToPath, isAnnotate, loadConfig, resolveConfigFile } from "@atscript/core";
 import { tsPlugin } from "@atscript/typescript";
 
 //#region packages/unplugin/src/index.ts
 const RE_DTS = /\.d\.[cm]?ts$/;
 const RUNTIME_ENTRY = "@atscript/typescript/utils";
+/**
+* Registers every transitive `.as` dependency of `doc` as a watch file.
+*
+* The bundler's module graph only knows the imports the rendered output keeps:
+* the JS renderer drops imports it does not use, and the dts graph and
+* non-Vite watchers never see the JS import list at all. Watching the whole
+* `.as` closure explicitly makes the bundler re-run `load` for the importer
+* whenever any of them changes.
+*
+* Re-registering on every `load` is required: Vite replaces a module's watch
+* edges on each transform, so a repeat registration is deduped while skipping
+* it would prune the edge.
+*/ function addTransitiveWatchFiles(ctx, doc, visited = new Set([doc])) {
+	for (const dep of doc.dependencies) {
+		if (visited.has(dep)) continue;
+		visited.add(dep);
+		ctx.addWatchFile(fileUriToPath(dep.id));
+		addTransitiveWatchFiles(ctx, dep, visited);
+	}
+}
 function isResolvableFrom(specifier, from) {
 	try {
 		createRequire(path.join(from, "package.json")).resolve(specifier);
@@ -59,6 +79,7 @@ const unpluginFactory = (opts) => {
 				const code = (await readFile(sourceId, "utf8")).toString();
 				const doc = await repo.openDocument(`file://${sourceId}`, code);
 				await repo.checkDoc(doc);
+				addTransitiveWatchFiles(this, doc);
 				const messages = doc.getDiagMessages().reverse();
 				let error = "";
 				for (const m of messages) if (m.severity === 1) {
@@ -79,6 +100,10 @@ const unpluginFactory = (opts) => {
 					moduleSideEffects: hasMutatingAnnotates ? void 0 : false
 				};
 			}
+		},
+		watchChange(id) {
+			if (!repo || !id.endsWith(".as")) return;
+			repo.closeDocument(`file://${id}`);
 		}
 	};
 };

package/dist/rollup.cjs

@@ -36,6 +36,26 @@ let _atscript_typescript = require("@atscript/typescript");
 //#region packages/unplugin/src/index.ts
 const RE_DTS = /\.d\.[cm]?ts$/;
 const RUNTIME_ENTRY = "@atscript/typescript/utils";
+/**
+* Registers every transitive `.as` dependency of `doc` as a watch file.
+*
+* The bundler's module graph only knows the imports the rendered output keeps:
+* the JS renderer drops imports it does not use, and the dts graph and
+* non-Vite watchers never see the JS import list at all. Watching the whole
+* `.as` closure explicitly makes the bundler re-run `load` for the importer
+* whenever any of them changes.
+*
+* Re-registering on every `load` is required: Vite replaces a module's watch
+* edges on each transform, so a repeat registration is deduped while skipping
+* it would prune the edge.
+*/ function addTransitiveWatchFiles(ctx, doc, visited = new Set([doc])) {
+	for (const dep of doc.dependencies) {
+		if (visited.has(dep)) continue;
+		visited.add(dep);
+		ctx.addWatchFile((0, _atscript_core.fileUriToPath)(dep.id));
+		addTransitiveWatchFiles(ctx, dep, visited);
+	}
+}
 function isResolvableFrom(specifier, from) {
 	try {
 		(0, module$1.createRequire)(path.default.join(from, "package.json")).resolve(specifier);
@@ -87,6 +107,7 @@ const unpluginFactory = (opts) => {
 				const code = (await (0, fs_promises.readFile)(sourceId, "utf8")).toString();
 				const doc = await repo.openDocument(`file://${sourceId}`, code);
 				await repo.checkDoc(doc);
+				addTransitiveWatchFiles(this, doc);
 				const messages = doc.getDiagMessages().reverse();
 				let error = "";
 				for (const m of messages) if (m.severity === 1) {
@@ -107,6 +128,10 @@ const unpluginFactory = (opts) => {
 					moduleSideEffects: hasMutatingAnnotates ? void 0 : false
 				};
 			}
+		},
+		watchChange(id) {
+			if (!repo || !id.endsWith(".as")) return;
+			repo.closeDocument(`file://${id}`);
 		}
 	};
 };

package/dist/rollup.mjs

@@ -2,12 +2,32 @@ import { createRollupPlugin } from "unplugin";
 import { readFile } from "fs/promises";
 import { createRequire } from "module";
 import path from "path";
-import { AtscriptRepo, isAnnotate, loadConfig, resolveConfigFile } from "@atscript/core";
+import { AtscriptRepo, fileUriToPath, isAnnotate, loadConfig, resolveConfigFile } from "@atscript/core";
 import { tsPlugin } from "@atscript/typescript";
 
 //#region packages/unplugin/src/index.ts
 const RE_DTS = /\.d\.[cm]?ts$/;
 const RUNTIME_ENTRY = "@atscript/typescript/utils";
+/**
+* Registers every transitive `.as` dependency of `doc` as a watch file.
+*
+* The bundler's module graph only knows the imports the rendered output keeps:
+* the JS renderer drops imports it does not use, and the dts graph and
+* non-Vite watchers never see the JS import list at all. Watching the whole
+* `.as` closure explicitly makes the bundler re-run `load` for the importer
+* whenever any of them changes.
+*
+* Re-registering on every `load` is required: Vite replaces a module's watch
+* edges on each transform, so a repeat registration is deduped while skipping
+* it would prune the edge.
+*/ function addTransitiveWatchFiles(ctx, doc, visited = new Set([doc])) {
+	for (const dep of doc.dependencies) {
+		if (visited.has(dep)) continue;
+		visited.add(dep);
+		ctx.addWatchFile(fileUriToPath(dep.id));
+		addTransitiveWatchFiles(ctx, dep, visited);
+	}
+}
 function isResolvableFrom(specifier, from) {
 	try {
 		createRequire(path.join(from, "package.json")).resolve(specifier);
@@ -59,6 +79,7 @@ const unpluginFactory = (opts) => {
 				const code = (await readFile(sourceId, "utf8")).toString();
 				const doc = await repo.openDocument(`file://${sourceId}`, code);
 				await repo.checkDoc(doc);
+				addTransitiveWatchFiles(this, doc);
 				const messages = doc.getDiagMessages().reverse();
 				let error = "";
 				for (const m of messages) if (m.severity === 1) {
@@ -79,6 +100,10 @@ const unpluginFactory = (opts) => {
 					moduleSideEffects: hasMutatingAnnotates ? void 0 : false
 				};
 			}
+		},
+		watchChange(id) {
+			if (!repo || !id.endsWith(".as")) return;
+			repo.closeDocument(`file://${id}`);
 		}
 	};
 };

package/dist/rspack.cjs

@@ -36,6 +36,26 @@ let _atscript_typescript = require("@atscript/typescript");
 //#region packages/unplugin/src/index.ts
 const RE_DTS = /\.d\.[cm]?ts$/;
 const RUNTIME_ENTRY = "@atscript/typescript/utils";
+/**
+* Registers every transitive `.as` dependency of `doc` as a watch file.
+*
+* The bundler's module graph only knows the imports the rendered output keeps:
+* the JS renderer drops imports it does not use, and the dts graph and
+* non-Vite watchers never see the JS import list at all. Watching the whole
+* `.as` closure explicitly makes the bundler re-run `load` for the importer
+* whenever any of them changes.
+*
+* Re-registering on every `load` is required: Vite replaces a module's watch
+* edges on each transform, so a repeat registration is deduped while skipping
+* it would prune the edge.
+*/ function addTransitiveWatchFiles(ctx, doc, visited = new Set([doc])) {
+	for (const dep of doc.dependencies) {
+		if (visited.has(dep)) continue;
+		visited.add(dep);
+		ctx.addWatchFile((0, _atscript_core.fileUriToPath)(dep.id));
+		addTransitiveWatchFiles(ctx, dep, visited);
+	}
+}
 function isResolvableFrom(specifier, from) {
 	try {
 		(0, module$1.createRequire)(path.default.join(from, "package.json")).resolve(specifier);
@@ -87,6 +107,7 @@ const unpluginFactory = (opts) => {
 				const code = (await (0, fs_promises.readFile)(sourceId, "utf8")).toString();
 				const doc = await repo.openDocument(`file://${sourceId}`, code);
 				await repo.checkDoc(doc);
+				addTransitiveWatchFiles(this, doc);
 				const messages = doc.getDiagMessages().reverse();
 				let error = "";
 				for (const m of messages) if (m.severity === 1) {
@@ -107,6 +128,10 @@ const unpluginFactory = (opts) => {
 					moduleSideEffects: hasMutatingAnnotates ? void 0 : false
 				};
 			}
+		},
+		watchChange(id) {
+			if (!repo || !id.endsWith(".as")) return;
+			repo.closeDocument(`file://${id}`);
 		}
 	};
 };

package/dist/rspack.mjs

@@ -2,12 +2,32 @@ import { createRspackPlugin } from "unplugin";
 import { readFile } from "fs/promises";
 import { createRequire } from "module";
 import path from "path";
-import { AtscriptRepo, isAnnotate, loadConfig, resolveConfigFile } from "@atscript/core";
+import { AtscriptRepo, fileUriToPath, isAnnotate, loadConfig, resolveConfigFile } from "@atscript/core";
 import { tsPlugin } from "@atscript/typescript";
 
 //#region packages/unplugin/src/index.ts
 const RE_DTS = /\.d\.[cm]?ts$/;
 const RUNTIME_ENTRY = "@atscript/typescript/utils";
+/**
+* Registers every transitive `.as` dependency of `doc` as a watch file.
+*
+* The bundler's module graph only knows the imports the rendered output keeps:
+* the JS renderer drops imports it does not use, and the dts graph and
+* non-Vite watchers never see the JS import list at all. Watching the whole
+* `.as` closure explicitly makes the bundler re-run `load` for the importer
+* whenever any of them changes.
+*
+* Re-registering on every `load` is required: Vite replaces a module's watch
+* edges on each transform, so a repeat registration is deduped while skipping
+* it would prune the edge.
+*/ function addTransitiveWatchFiles(ctx, doc, visited = new Set([doc])) {
+	for (const dep of doc.dependencies) {
+		if (visited.has(dep)) continue;
+		visited.add(dep);
+		ctx.addWatchFile(fileUriToPath(dep.id));
+		addTransitiveWatchFiles(ctx, dep, visited);
+	}
+}
 function isResolvableFrom(specifier, from) {
 	try {
 		createRequire(path.join(from, "package.json")).resolve(specifier);
@@ -59,6 +79,7 @@ const unpluginFactory = (opts) => {
 				const code = (await readFile(sourceId, "utf8")).toString();
 				const doc = await repo.openDocument(`file://${sourceId}`, code);
 				await repo.checkDoc(doc);
+				addTransitiveWatchFiles(this, doc);
 				const messages = doc.getDiagMessages().reverse();
 				let error = "";
 				for (const m of messages) if (m.severity === 1) {
@@ -79,6 +100,10 @@ const unpluginFactory = (opts) => {
 					moduleSideEffects: hasMutatingAnnotates ? void 0 : false
 				};
 			}
+		},
+		watchChange(id) {
+			if (!repo || !id.endsWith(".as")) return;
+			repo.closeDocument(`file://${id}`);
 		}
 	};
 };

package/dist/vite.cjs

@@ -36,6 +36,26 @@ let _atscript_typescript = require("@atscript/typescript");
 //#region packages/unplugin/src/index.ts
 const RE_DTS = /\.d\.[cm]?ts$/;
 const RUNTIME_ENTRY = "@atscript/typescript/utils";
+/**
+* Registers every transitive `.as` dependency of `doc` as a watch file.
+*
+* The bundler's module graph only knows the imports the rendered output keeps:
+* the JS renderer drops imports it does not use, and the dts graph and
+* non-Vite watchers never see the JS import list at all. Watching the whole
+* `.as` closure explicitly makes the bundler re-run `load` for the importer
+* whenever any of them changes.
+*
+* Re-registering on every `load` is required: Vite replaces a module's watch
+* edges on each transform, so a repeat registration is deduped while skipping
+* it would prune the edge.
+*/ function addTransitiveWatchFiles(ctx, doc, visited = new Set([doc])) {
+	for (const dep of doc.dependencies) {
+		if (visited.has(dep)) continue;
+		visited.add(dep);
+		ctx.addWatchFile((0, _atscript_core.fileUriToPath)(dep.id));
+		addTransitiveWatchFiles(ctx, dep, visited);
+	}
+}
 function isResolvableFrom(specifier, from) {
 	try {
 		(0, module$1.createRequire)(path.default.join(from, "package.json")).resolve(specifier);
@@ -87,6 +107,7 @@ const unpluginFactory = (opts) => {
 				const code = (await (0, fs_promises.readFile)(sourceId, "utf8")).toString();
 				const doc = await repo.openDocument(`file://${sourceId}`, code);
 				await repo.checkDoc(doc);
+				addTransitiveWatchFiles(this, doc);
 				const messages = doc.getDiagMessages().reverse();
 				let error = "";
 				for (const m of messages) if (m.severity === 1) {
@@ -107,6 +128,10 @@ const unpluginFactory = (opts) => {
 					moduleSideEffects: hasMutatingAnnotates ? void 0 : false
 				};
 			}
+		},
+		watchChange(id) {
+			if (!repo || !id.endsWith(".as")) return;
+			repo.closeDocument(`file://${id}`);
 		}
 	};
 };

package/dist/vite.mjs

@@ -2,12 +2,32 @@ import { createVitePlugin } from "unplugin";
 import { readFile } from "fs/promises";
 import { createRequire } from "module";
 import path from "path";
-import { AtscriptRepo, isAnnotate, loadConfig, resolveConfigFile } from "@atscript/core";
+import { AtscriptRepo, fileUriToPath, isAnnotate, loadConfig, resolveConfigFile } from "@atscript/core";
 import { tsPlugin } from "@atscript/typescript";
 
 //#region packages/unplugin/src/index.ts
 const RE_DTS = /\.d\.[cm]?ts$/;
 const RUNTIME_ENTRY = "@atscript/typescript/utils";
+/**
+* Registers every transitive `.as` dependency of `doc` as a watch file.
+*
+* The bundler's module graph only knows the imports the rendered output keeps:
+* the JS renderer drops imports it does not use, and the dts graph and
+* non-Vite watchers never see the JS import list at all. Watching the whole
+* `.as` closure explicitly makes the bundler re-run `load` for the importer
+* whenever any of them changes.
+*
+* Re-registering on every `load` is required: Vite replaces a module's watch
+* edges on each transform, so a repeat registration is deduped while skipping
+* it would prune the edge.
+*/ function addTransitiveWatchFiles(ctx, doc, visited = new Set([doc])) {
+	for (const dep of doc.dependencies) {
+		if (visited.has(dep)) continue;
+		visited.add(dep);
+		ctx.addWatchFile(fileUriToPath(dep.id));
+		addTransitiveWatchFiles(ctx, dep, visited);
+	}
+}
 function isResolvableFrom(specifier, from) {
 	try {
 		createRequire(path.join(from, "package.json")).resolve(specifier);
@@ -59,6 +79,7 @@ const unpluginFactory = (opts) => {
 				const code = (await readFile(sourceId, "utf8")).toString();
 				const doc = await repo.openDocument(`file://${sourceId}`, code);
 				await repo.checkDoc(doc);
+				addTransitiveWatchFiles(this, doc);
 				const messages = doc.getDiagMessages().reverse();
 				let error = "";
 				for (const m of messages) if (m.severity === 1) {
@@ -79,6 +100,10 @@ const unpluginFactory = (opts) => {
 					moduleSideEffects: hasMutatingAnnotates ? void 0 : false
 				};
 			}
+		},
+		watchChange(id) {
+			if (!repo || !id.endsWith(".as")) return;
+			repo.closeDocument(`file://${id}`);
 		}
 	};
 };

package/dist/webpack.cjs

@@ -36,6 +36,26 @@ let _atscript_typescript = require("@atscript/typescript");
 //#region packages/unplugin/src/index.ts
 const RE_DTS = /\.d\.[cm]?ts$/;
 const RUNTIME_ENTRY = "@atscript/typescript/utils";
+/**
+* Registers every transitive `.as` dependency of `doc` as a watch file.
+*
+* The bundler's module graph only knows the imports the rendered output keeps:
+* the JS renderer drops imports it does not use, and the dts graph and
+* non-Vite watchers never see the JS import list at all. Watching the whole
+* `.as` closure explicitly makes the bundler re-run `load` for the importer
+* whenever any of them changes.
+*
+* Re-registering on every `load` is required: Vite replaces a module's watch
+* edges on each transform, so a repeat registration is deduped while skipping
+* it would prune the edge.
+*/ function addTransitiveWatchFiles(ctx, doc, visited = new Set([doc])) {
+	for (const dep of doc.dependencies) {
+		if (visited.has(dep)) continue;
+		visited.add(dep);
+		ctx.addWatchFile((0, _atscript_core.fileUriToPath)(dep.id));
+		addTransitiveWatchFiles(ctx, dep, visited);
+	}
+}
 function isResolvableFrom(specifier, from) {
 	try {
 		(0, module$1.createRequire)(path.default.join(from, "package.json")).resolve(specifier);
@@ -87,6 +107,7 @@ const unpluginFactory = (opts) => {
 				const code = (await (0, fs_promises.readFile)(sourceId, "utf8")).toString();
 				const doc = await repo.openDocument(`file://${sourceId}`, code);
 				await repo.checkDoc(doc);
+				addTransitiveWatchFiles(this, doc);
 				const messages = doc.getDiagMessages().reverse();
 				let error = "";
 				for (const m of messages) if (m.severity === 1) {
@@ -107,6 +128,10 @@ const unpluginFactory = (opts) => {
 					moduleSideEffects: hasMutatingAnnotates ? void 0 : false
 				};
 			}
+		},
+		watchChange(id) {
+			if (!repo || !id.endsWith(".as")) return;
+			repo.closeDocument(`file://${id}`);
 		}
 	};
 };

package/dist/webpack.mjs

@@ -2,12 +2,32 @@ import { createWebpackPlugin } from "unplugin";
 import { readFile } from "fs/promises";
 import { createRequire } from "module";
 import path from "path";
-import { AtscriptRepo, isAnnotate, loadConfig, resolveConfigFile } from "@atscript/core";
+import { AtscriptRepo, fileUriToPath, isAnnotate, loadConfig, resolveConfigFile } from "@atscript/core";
 import { tsPlugin } from "@atscript/typescript";
 
 //#region packages/unplugin/src/index.ts
 const RE_DTS = /\.d\.[cm]?ts$/;
 const RUNTIME_ENTRY = "@atscript/typescript/utils";
+/**
+* Registers every transitive `.as` dependency of `doc` as a watch file.
+*
+* The bundler's module graph only knows the imports the rendered output keeps:
+* the JS renderer drops imports it does not use, and the dts graph and
+* non-Vite watchers never see the JS import list at all. Watching the whole
+* `.as` closure explicitly makes the bundler re-run `load` for the importer
+* whenever any of them changes.
+*
+* Re-registering on every `load` is required: Vite replaces a module's watch
+* edges on each transform, so a repeat registration is deduped while skipping
+* it would prune the edge.
+*/ function addTransitiveWatchFiles(ctx, doc, visited = new Set([doc])) {
+	for (const dep of doc.dependencies) {
+		if (visited.has(dep)) continue;
+		visited.add(dep);
+		ctx.addWatchFile(fileUriToPath(dep.id));
+		addTransitiveWatchFiles(ctx, dep, visited);
+	}
+}
 function isResolvableFrom(specifier, from) {
 	try {
 		createRequire(path.join(from, "package.json")).resolve(specifier);
@@ -59,6 +79,7 @@ const unpluginFactory = (opts) => {
 				const code = (await readFile(sourceId, "utf8")).toString();
 				const doc = await repo.openDocument(`file://${sourceId}`, code);
 				await repo.checkDoc(doc);
+				addTransitiveWatchFiles(this, doc);
 				const messages = doc.getDiagMessages().reverse();
 				let error = "";
 				for (const m of messages) if (m.severity === 1) {
@@ -79,6 +100,10 @@ const unpluginFactory = (opts) => {
 					moduleSideEffects: hasMutatingAnnotates ? void 0 : false
 				};
 			}
+		},
+		watchChange(id) {
+			if (!repo || !id.endsWith(".as")) return;
+			repo.closeDocument(`file://${id}`);
 		}
 	};
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unplugin-atscript",
-  "version": "0.1.91",
+  "version": "0.1.92",
   "description": "Atscript: Configuration and build plugins.",
   "keywords": [
     "annotations",
@@ -82,8 +82,8 @@
     "vitest": "3.2.7"
   },
   "peerDependencies": {
-    "@atscript/core": "^0.1.91",
-    "@atscript/typescript": "^0.1.91"
+    "@atscript/core": "^0.1.92",
+    "@atscript/typescript": "^0.1.92"
   },
   "build": [
     {},