@alwaysmeticulous/backend-recorder-workerd 2.327.0 → 2.330.0

package/dist/vite/index.d.ts

@@ -0,0 +1,62 @@
+//#region src/vite/index.d.ts
+/**
+ * Vite plugin that instruments a Worker's server modules for Meticulous line
+ * coverage.
+ *
+ * Add it to the build you upload for testing — not the one you ship:
+ *
+ *   import { meticulousCoverage } from "@alwaysmeticulous/backend-recorder-workerd/vite";
+ *   export default defineConfig({ plugins: [meticulousCoverage()] });
+ *
+ * `enforce: "post"` is deliberate: by then Vite's esbuild pass has already
+ * stripped TypeScript and JSX, so the instrumenter only ever sees plain JS and
+ * needs no TS-aware parser. Anything it still cannot parse is passed through
+ * untouched — coverage is never worth failing a customer's build for.
+ *
+ * The cost of running last is that AST line numbers are lines in the re-printed
+ * module, not in the file the customer wrote — that pass drops comments and
+ * blank lines, which on a commented codebase shifts nearly every statement. So
+ * each marker's line is resolved back through `getCombinedSourcemap()`, the
+ * transform chain's accumulated map, which is only available here in the
+ * transform hook.
+ */
+/**
+ * The slice of Vite's transform-hook context this uses. Optional because the
+ * plugin must still work when called without one — a bare `plugin.transform(...)`
+ * in a test, or a host that does not provide the hook.
+ */
+interface TransformContextLike {
+  getCombinedSourcemap?: () => unknown;
+}
+/** Structural subset of a Vite plugin — avoids depending on vite's types. */
+interface VitePluginLike {
+  name: string;
+  enforce?: "pre" | "post";
+  configResolved?: (config: {
+    root?: string;
+  }) => void;
+  transform?: (this: TransformContextLike | undefined, code: string, id: string, options?: {
+    ssr?: boolean;
+  }) => {
+    code: string;
+    map: string;
+  } | null;
+  buildEnd?: () => void;
+}
+interface MeticulousCoverageOptions {
+  /**
+   * Instrument client modules too. Off by default: only the server build runs
+   * inside workerd, and it is the only side Meticulous replays.
+   */
+  includeClient?: boolean;
+  /** Extra paths to leave uninstrumented, on top of node_modules and virtual modules. */
+  exclude?: RegExp[];
+  /** Overrides where the injected runtime import points (tests use this). */
+  runtimeModuleId?: string;
+  /** Receives a warning when the build produced no instrumentation at all. */
+  onWarning?: (message: string) => void;
+}
+declare const meticulousCoverage: (options?: MeticulousCoverageOptions) => VitePluginLike;
+//#endregion
+export { MeticulousCoverageOptions, TransformContextLike, VitePluginLike, meticulousCoverage };
+//# sourceMappingURL=index.d.ts.map