@simplysm/sd-cli 14.0.15 → 14.0.17

package/src/utils/vite-pwa-plugin.ts

@@ -0,0 +1,168 @@
+import type { PluginOption, ResolvedConfig } from "vite";
+import type { SdPwaConfig } from "../sd-config.types.js";
+import { generatePwaIcons } from "./generate-pwa-icons.js";
+import fs from "node:fs";
+import path from "node:path";
+import { glob } from "glob";
+
+export interface SdPwaPluginOptions {
+  pkgDir: string;
+  pkgName: string;
+  pwa?: SdPwaConfig;
+}
+
+export function sdPwaPlugin(options: SdPwaPluginOptions): PluginOption {
+  const pwaConfig = options.pwa ?? {};
+  let resolvedBase: string;
+  let resolvedOutDir: string;
+
+  return {
+    name: "sd-pwa",
+
+    configResolved(config: ResolvedConfig) {
+      resolvedBase = config.base;
+      resolvedOutDir = config.build.outDir;
+    },
+
+    transformIndexHtml() {
+      return [
+        {
+          tag: "link",
+          attrs: { rel: "manifest", href: "manifest.webmanifest" },
+          injectTo: "head" as const,
+        },
+        {
+          tag: "script",
+          children: generateRegistrationScript(),
+          injectTo: "body" as const,
+        },
+      ];
+    },
+
+    async closeBundle() {
+      // Read version from package.json
+      const pkgJsonPath = path.join(options.pkgDir, "package.json");
+      const pkgJson = JSON.parse(
+        fs.readFileSync(pkgJsonPath, "utf-8"),
+      ) as Record<string, unknown>;
+      const version = pkgJson["version"] as string;
+
+      // Icons
+      let iconsField: Record<string, unknown> = {};
+      if (pwaConfig.manifest?.icons != null) {
+        iconsField = { icons: pwaConfig.manifest.icons };
+      } else {
+        const generated = await generatePwaIcons(options.pkgDir);
+        if (generated.length > 0) {
+          iconsField = { icons: generated };
+        }
+      }
+
+      // Manifest
+      const manifest = {
+        name: pwaConfig.manifest?.name ?? options.pkgName,
+        short_name: pwaConfig.manifest?.short_name ?? options.pkgName,
+        display: pwaConfig.manifest?.display ?? "standalone",
+        theme_color: pwaConfig.manifest?.theme_color ?? "#ffffff",
+        background_color: pwaConfig.manifest?.background_color ?? "#ffffff",
+        start_url: ".",
+        scope: ".",
+        ...iconsField,
+      };
+
+      fs.writeFileSync(
+        path.join(resolvedOutDir, "manifest.webmanifest"),
+        JSON.stringify(manifest, null, 2),
+      );
+
+      // Precache file list
+      const globPatterns = pwaConfig.workbox?.globPatterns ?? [
+        "**/*.{js,css,html,ico,png,svg,woff2}",
+      ];
+      const globResults = await Promise.all(
+        globPatterns.map((pattern) => glob(pattern, { cwd: resolvedOutDir })),
+      );
+      const precacheUrls = [...new Set(globResults.flat())]
+        .filter((f) => f !== "sw.js" && f !== "manifest.webmanifest")
+        .map((f) => f.replace(/\\/g, "/"));
+
+      // Service Worker
+      const swContent = generateSwContent(version, resolvedBase, precacheUrls);
+      fs.writeFileSync(path.join(resolvedOutDir, "sw.js"), swContent);
+    },
+  };
+}
+
+function generateRegistrationScript(): string {
+  return `(function(){
+  if(!("serviceWorker" in navigator))return;
+  navigator.serviceWorker.register("sw.js").then(function(reg){
+    if(reg.waiting){d(reg.waiting);return}
+    reg.addEventListener("updatefound",function(){
+      var w=reg.installing;
+      if(!w)return;
+      w.addEventListener("statechange",function(){
+        if(w.state==="installed"&&navigator.serviceWorker.controller)d(w);
+      });
+    });
+  });
+  var r=false;
+  navigator.serviceWorker.addEventListener("controllerchange",function(){
+    if(!r){r=true;window.location.reload()}
+  });
+  function d(w){
+    window.dispatchEvent(new CustomEvent("sd-pwa-update-ready",{
+      detail:{update:function(){w.postMessage({type:"SKIP_WAITING"})}}
+    }));
+  }
+})();`;
+}
+
+function generateSwContent(
+  version: string,
+  base: string,
+  precacheUrls: string[],
+): string {
+  const urlsArray = JSON.stringify(precacheUrls, null, 2);
+  return `const APP_VERSION = ${JSON.stringify(version)};
+const CACHE_NAME = "precache-" + APP_VERSION;
+const BASE_URL = ${JSON.stringify(base)};
+const PRECACHE_URLS = ${urlsArray};
+
+self.addEventListener("install", (event) => {
+  event.waitUntil(
+    caches.open(CACHE_NAME).then((cache) => cache.addAll(PRECACHE_URLS))
+  );
+});
+
+self.addEventListener("activate", (event) => {
+  event.waitUntil(
+    caches.keys().then((names) =>
+      Promise.all(
+        names
+          .filter((name) => name.startsWith("precache-") && name !== CACHE_NAME)
+          .map((name) => caches.delete(name))
+      )
+    ).then(() => self.clients.claim())
+  );
+});
+
+self.addEventListener("fetch", (event) => {
+  event.respondWith(
+    caches.match(event.request).then((cached) => {
+      if (cached) return cached;
+      if (event.request.mode === "navigate") {
+        return caches.match(BASE_URL + "index.html").then((resp) => resp || fetch(event.request));
+      }
+      return fetch(event.request);
+    })
+  );
+});
+
+self.addEventListener("message", (event) => {
+  if (event.data && event.data.type === "SKIP_WAITING") {
+    self.skipWaiting();
+  }
+});
+`;
+}

package/src/utils/worker-utils.ts

@@ -1,18 +1,12 @@
-import consola, { type ConsolaInstance, LogLevels } from "consola";
-import { SdCliReporter } from "./SdCliReporter";
+import { type ConsolaInstance } from "consola";
+import { setupConsola } from "@simplysm/core-node";
 
 /**
- * 워커 스레드에서 sd-cli 리포터와 디버그 로그 레벨을 적용한다.
- *
- * SD_DEBUG 환경변수(메인 프로세스의 --debug 플래그로 설정)를 확인하고
- * 현재 워커 스레드의 consola에 디버그 로그 레벨을 적용한다.
+ * 워커 스레드에서 consola를 설정한다.
  * 워커 모듈 최상위에서 호출해야 한다.
  */
-export function applyDebugLevel(): void {
-  consola.options.reporters = [new SdCliReporter()];
-  if (process.env["SD_DEBUG"] === "true") {
-    consola.level = LogLevels.debug;
-  }
+export function setupWorkerConsola(): void {
+  setupConsola({ cli: true });
 }
 
 /**

package/src/workers/client.worker.ts

@@ -6,13 +6,13 @@ import mime from "mime";
 import { createWorker } from "@simplysm/core-node";
 import { err as errNs } from "@simplysm/core-common";
 import { consola } from "consola";
-import { registerCleanupHandlers, applyDebugLevel } from "../utils/worker-utils.js";
+import { registerCleanupHandlers, setupWorkerConsola } from "../utils/worker-utils.js";
 import { createClientViteConfig } from "../utils/vite-config.js";
 import type { ScopeWatchReplaceDep } from "../utils/vite-scope-watch-plugin.js";
 import type { SdBrowserSupportConfig, SdPwaConfig } from "../sd-config.types.js";
 import type { LintWithProgramResult } from "../utils/lint-with-program.js";
 
-applyDebugLevel();
+setupWorkerConsola();
 
 //#region Types
 
@@ -247,8 +247,13 @@ async function startWatch(info: ClientBuildInfo): Promise<ClientBuildResult> {
 
     sender.send("serverReady", { port: actualPort });
 
+    // .dev-port 기록 (device 명령어에서 자동 탐지용)
+    const distDir = path.join(info.pkgDir, "dist");
+    fs.mkdirSync(distDir, { recursive: true });
+    fs.writeFileSync(path.join(distDir, ".dev-port"), String(actualPort));
+
     // .config.json 생성
-    writeConfigJson(path.join(info.pkgDir, "dist"), info.configs);
+    writeConfigJson(distDir, info.configs);
 
     return { success: true };
   } catch (err) {
@@ -323,6 +328,9 @@ async function startLegacyWatch(info: ClientBuildInfo): Promise<ClientBuildResul
 
     sender.send("serverReady", { port: serverPort });
 
+    // .dev-port 기록 (device 명령어에서 자동 탐지용)
+    fs.writeFileSync(path.join(info.pkgDir, "dist", ".dev-port"), String(serverPort));
+
     // 첫 빌드 완료 대기
     return await new Promise<ClientBuildResult>((resolve) => {
       let firstBuildResolved = false;

package/src/workers/library-build.worker.ts

@@ -9,9 +9,9 @@ import type { LintWithProgramResult } from "../utils/lint-with-program";
 import { runTscPackageBuild } from "../utils/tsc-build";
 import { LintWithProgramRunner } from "../utils/lint-with-program";
 import { collectDeps } from "../utils/package-utils";
-import { registerCleanupHandlers, createOnceGuard, applyDebugLevel } from "../utils/worker-utils";
+import { registerCleanupHandlers, createOnceGuard, setupWorkerConsola } from "../utils/worker-utils";
 
-applyDebugLevel();
+setupWorkerConsola();
 
 //#region Types
 
@@ -53,6 +53,7 @@ async function cleanup(): Promise<void> {
   const watcherToClose = fsWatcher;
   fsWatcher = undefined;
   lastSourceFilePaths = undefined;
+  lastBuilderProgram = undefined;
   await watcherToClose?.close();
 }
 
@@ -106,6 +107,7 @@ const guardStartWatch = createOnceGuard("startWatch");
 let watchInfo: LibraryBuildInfo | undefined;
 let watchLintRunner: LintWithProgramRunner | undefined;
 let lastSourceFilePaths: Set<string> | undefined;
+let lastBuilderProgram: ts.EmitAndSemanticDiagnosticsBuilderProgram | undefined;
 
 function extractSourceFilePaths(program: ts.Program | undefined): Set<string> | undefined {
   if (program == null) return undefined;
@@ -126,7 +128,9 @@ async function rebuildAll(): Promise<CombinedBuildEvent> {
     output: info.output,
     env: info.output.env,
     includeTests: info.output.includeTests,
+    oldBuilderProgram: lastBuilderProgram,
   });
+  lastBuilderProgram = tscResult.builderProgram ?? lastBuilderProgram;
 
   // 의존성 필터링을 위한 소스 파일 경로 업데이트
   lastSourceFilePaths = extractSourceFilePaths(tscResult.program) ?? lastSourceFilePaths;

package/src/workers/ngtsc-build.worker.ts

@@ -3,7 +3,7 @@ import ts from "typescript";
 import { createWorker, FsWatcher, pathx } from "@simplysm/core-node";
 import { err as errNs } from "@simplysm/core-common";
 import { consola } from "consola";
-import { registerCleanupHandlers, createOnceGuard, applyDebugLevel } from "../utils/worker-utils";
+import { registerCleanupHandlers, createOnceGuard, setupWorkerConsola } from "../utils/worker-utils";
 import {
   runNgtscBuild,
   buildCompilerOptions,
@@ -28,7 +28,7 @@ import {
 import { AngularCompiler, AngularSourceFileCache } from "../utils/angular-compiler";
 import { collectDeps } from "../utils/package-utils";
 
-applyDebugLevel();
+setupWorkerConsola();
 
 //#region 타입 (워커 인터페이스용 re-export)
 

package/src/workers/server-build.worker.ts

@@ -1,3 +1,4 @@
+import type ts from "typescript";
 import path from "path";
 import fs from "fs";
 import esbuild from "esbuild";
@@ -18,7 +19,7 @@ import {
 } from "../utils/esbuild-config";
 import { runTscPackageBuild } from "../utils/tsc-build";
 import { LintWithProgramRunner } from "../utils/lint-with-program";
-import { registerCleanupHandlers, createOnceGuard, applyDebugLevel } from "../utils/worker-utils";
+import { registerCleanupHandlers, createOnceGuard, setupWorkerConsola } from "../utils/worker-utils";
 import { collectDeps } from "../utils/package-utils";
 import { copyPublicFiles, watchPublicFiles } from "../utils/copy-public";
 
@@ -96,7 +97,7 @@ export interface ServerBuildWorkerEvents extends Record<string, unknown> {
 
 //#region Resource Management
 
-applyDebugLevel();
+setupWorkerConsola();
 
 const logger = consola.withTag("sd:cli:server-build:worker");
 
@@ -116,6 +117,7 @@ async function cleanup(): Promise<void> {
   const contextToDispose = esbuildContext;
   esbuildContext = undefined;
   lastMetafile = undefined;
+  lastBuilderProgram = undefined;
 
   const watcherToClose = publicWatcher;
   publicWatcher = undefined;
@@ -427,6 +429,7 @@ const guardStartWatch = createOnceGuard("startWatch");
 // watch 모드용 가변 상태
 let watchInfo: ServerWatchInfo | undefined;
 let watchLintRunner: LintWithProgramRunner | undefined;
+let lastBuilderProgram: ts.EmitAndSemanticDiagnosticsBuilderProgram | undefined;
 
 /**
  * esbuild + tsc 병렬 리빌드 (watch 모드)
@@ -467,7 +470,9 @@ async function rebuildAll(): Promise<ServerCombinedBuildEvent> {
     parsedConfig,
     env: info.output.env,
     includeTests: info.output.includeTests,
+    oldBuilderProgram: lastBuilderProgram,
   });
+  lastBuilderProgram = tscResult.builderProgram ?? lastBuilderProgram;
 
   // lint 실행 (활성화 + program 사용 가능 시)
   let lint: LintWithProgramResult | undefined;

package/src/workers/server-runtime.worker.ts

@@ -1,10 +1,10 @@
 import { createWorker } from "@simplysm/core-node";
-import { err as errNs } from "@simplysm/core-common";
+import { env, err as errNs } from "@simplysm/core-common";
 import { consola } from "consola";
 import proxy from "@fastify/http-proxy";
 import net from "net";
 import { pathToFileURL } from "url";
-import { registerCleanupHandlers, applyDebugLevel } from "../utils/worker-utils";
+import { registerCleanupHandlers, setupWorkerConsola } from "../utils/worker-utils";
 
 //#region Types
 
@@ -42,7 +42,7 @@ export interface ServerRuntimeWorkerEvents extends Record<string, unknown> {
 
 //#endregion
 
-applyDebugLevel();
+setupWorkerConsola();
 
 const logger = consola.withTag("sd:cli:server-runtime:worker");
 
@@ -122,7 +122,7 @@ async function start(info: ServerRuntimeStartInfo): Promise<void> {
     // main.js import 전에 환경변수를 process.env에 주입
     if (info.env != null) {
       for (const [key, value] of Object.entries(info.env)) {
-        process.env[key] = value;
+        env(key, value);
       }
     }
 

package/tests/angular/client-transform-stylesheet.spec.ts

@@ -3,6 +3,7 @@ import path from "path";
 import fs from "fs";
 import os from "os";
 import { createClientTransformStylesheet } from "../../src/angular/client-transform-stylesheet.js";
+import { compileScssFileAsync, compileScssStringAsync } from "../../src/utils/scss-compiler.js";
 
 const TMP_DIR = path.join(os.tmpdir(), "sd-cli-stylesheet-test");
 
@@ -151,3 +152,45 @@ describe("createClientTransformStylesheet", () => {
     expect(deps.size).toBeGreaterThan(0);
   });
 });
+
+// ─── scss-compiler async (low-level) ───
+
+describe("scss-compiler async", () => {
+  // Scenario: 외부 .scss 파일 변환
+  it("compiles external .scss file asynchronously", async () => {
+    ensureTmpDir();
+    const scssPath = path.join(TMP_DIR, "test.scss");
+    fs.writeFileSync(scssPath, "$color: red;\n.host { color: $color; }");
+
+    const result = await compileScssFileAsync(scssPath, []);
+
+    expect(result.css).toContain("color: red");
+    expect(result.css).not.toContain("$color");
+    expect(result.dependencies).toBeInstanceOf(Array);
+  });
+
+  // Scenario: 인라인 SCSS 문자열 변환
+  it("compiles inline SCSS string asynchronously", async () => {
+    ensureTmpDir();
+    const containingFile = path.join(TMP_DIR, "component.ts");
+
+    const result = await compileScssStringAsync(
+      "$size: 16px;\n.text { font-size: $size; }",
+      containingFile,
+      [],
+    );
+
+    expect(result.css).toContain("font-size: 16px");
+    expect(result.css).not.toContain("$size");
+    expect(result.dependencies).toBeInstanceOf(Array);
+  });
+
+  // Scenario: SCSS 컴파일 에러 시 에러
+  it("throws on invalid SCSS syntax", async () => {
+    ensureTmpDir();
+    const scssPath = path.join(TMP_DIR, "invalid.scss");
+    fs.writeFileSync(scssPath, ".host { @include nonexistent-mixin(); }");
+
+    await expect(compileScssFileAsync(scssPath, [])).rejects.toThrow();
+  });
+});

package/tests/angular/find-affected-by-scss.spec.ts

@@ -0,0 +1,37 @@
+import { describe, it, expect } from "vitest";
+import { findAffectedByScss } from "../../src/angular/vite-angular-plugin.js";
+
+describe("findAffectedByScss", () => {
+  it("returns owner file when SCSS is in its dependency set", () => {
+    const deps = new Map<string, Set<string>>();
+    deps.set("/app/src/comp.ts", new Set(["/app/scss/_vars.scss"]));
+
+    const result = findAffectedByScss("/app/scss/_vars.scss", deps);
+    expect(result).toEqual(["/app/src/comp.ts"]);
+  });
+
+  it("returns multiple owners when multiple components depend on the same SCSS", () => {
+    const deps = new Map<string, Set<string>>();
+    deps.set("/app/src/comp-a.ts", new Set(["/app/scss/_vars.scss"]));
+    deps.set("/app/src/comp-b.ts", new Set(["/app/scss/_vars.scss", "/app/scss/_extra.scss"]));
+    deps.set("/app/src/comp-c.ts", new Set(["/app/scss/_other.scss"]));
+
+    const result = findAffectedByScss("/app/scss/_vars.scss", deps);
+    expect(result).toEqual(expect.arrayContaining(["/app/src/comp-a.ts", "/app/src/comp-b.ts"]));
+    expect(result).not.toContain("/app/src/comp-c.ts");
+  });
+
+  it("returns empty array when no component depends on the SCSS", () => {
+    const deps = new Map<string, Set<string>>();
+    deps.set("/app/src/comp.ts", new Set(["/app/scss/_vars.scss"]));
+
+    const result = findAffectedByScss("/app/scss/_unknown.scss", deps);
+    expect(result).toEqual([]);
+  });
+
+  it("returns empty array when scssDependencies is empty", () => {
+    const deps = new Map<string, Set<string>>();
+    const result = findAffectedByScss("/app/scss/_vars.scss", deps);
+    expect(result).toEqual([]);
+  });
+});

package/tests/angular/fixtures/basic-app/scss/_colors.scss

@@ -0,0 +1 @@
+$base: blue;

package/tests/angular/fixtures/basic-app/scss/_variables.scss

@@ -0,0 +1,3 @@
+@use 'colors' as c;
+
+$primary: c.$base;

package/tests/angular/fixtures/basic-app/src/styled.component.ts

@@ -0,0 +1,14 @@
+import { Component } from "@angular/core";
+
+@Component({
+  selector: "app-styled",
+  standalone: true,
+  template: `<p>styled</p>`,
+  styles: [`
+    @use 'variables' as vars;
+    :host {
+      color: vars.$primary;
+    }
+  `],
+})
+export class StyledComponent {}

package/tests/angular/linker-disk-cache.spec.ts

@@ -0,0 +1,158 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+const mockTransformFile = vi.fn(() => Promise.resolve("transformed-code"));
+
+vi.mock("@angular/build/private", () => ({
+  JavaScriptTransformer: class MockJSTransformer {
+    transformFile = mockTransformFile;
+    transformData = vi.fn(() => Promise.resolve(new TextEncoder().encode("transformed")));
+    close = vi.fn(() => Promise.resolve());
+  },
+}));
+
+const { sdAngularPlugin } = await import("../../src/angular/vite-angular-plugin.js");
+
+const TMP_DIR = path.join(os.tmpdir(), "sd-cli-linker-cache-test");
+const CACHE_DIR = path.join(TMP_DIR, "cache");
+
+type LoadHandler = (id: string) => Promise<string | null>;
+
+function getLoadHandler(plugin: ReturnType<typeof sdAngularPlugin>): LoadHandler {
+  const config = (plugin as any).config();
+  const rolldownPlugin = config.optimizeDeps.rolldownOptions.plugins[0] as {
+    load: (id: string) => Promise<string | null>;
+  };
+  return (id: string) => rolldownPlugin.load(id);
+}
+
+describe("Linker disk cache (optimizeDeps)", () => {
+  beforeEach(() => {
+    fs.mkdirSync(TMP_DIR, { recursive: true });
+    mockTransformFile.mockClear();
+    mockTransformFile.mockResolvedValue("transformed-code");
+  });
+
+  afterEach(() => {
+    fs.rmSync(TMP_DIR, { recursive: true, force: true });
+  });
+
+  // Acceptance: cache miss → transform + store, cache hit → load from disk
+  it("caches transformFile result on miss and returns cached on hit", async () => {
+    const jsFile = path.join(TMP_DIR, "module.js");
+    fs.writeFileSync(jsFile, "export const x = 1;");
+
+    const plugin = sdAngularPlugin({
+      tsconfig: path.join(TMP_DIR, "tsconfig.json"),
+      dev: true,
+      linkerCacheDir: CACHE_DIR,
+    });
+    const load = getLoadHandler(plugin);
+
+    // First call: cache miss
+    const result1 = await load(jsFile);
+    expect(mockTransformFile).toHaveBeenCalledOnce();
+    expect(result1).toBe("transformed-code");
+
+    // Cache file created
+    const cacheFiles = fs.readdirSync(CACHE_DIR);
+    expect(cacheFiles.length).toBe(1);
+    expect(cacheFiles[0]).toMatch(/^[a-f0-9]+\.js$/);
+
+    // Second call: cache hit
+    mockTransformFile.mockClear();
+    const result2 = await load(jsFile);
+    expect(mockTransformFile).not.toHaveBeenCalled();
+    expect(result2).toBe("transformed-code");
+  });
+
+  // Acceptance: file content change → cache miss
+  it("invalidates cache when file content changes", async () => {
+    const jsFile = path.join(TMP_DIR, "changing.js");
+    fs.writeFileSync(jsFile, "export const v = 1;");
+
+    const plugin = sdAngularPlugin({
+      tsconfig: path.join(TMP_DIR, "tsconfig.json"),
+      dev: true,
+      linkerCacheDir: CACHE_DIR,
+    });
+    const load = getLoadHandler(plugin);
+
+    await load(jsFile);
+    expect(mockTransformFile).toHaveBeenCalledOnce();
+
+    // Change content
+    fs.writeFileSync(jsFile, "export const v = 2;");
+    mockTransformFile.mockClear();
+    mockTransformFile.mockResolvedValue("transformed-v2");
+
+    const result = await load(jsFile);
+    expect(mockTransformFile).toHaveBeenCalledOnce();
+    expect(result).toBe("transformed-v2");
+  });
+
+  // Unit: corrupted cache file → graceful fallback
+  it("falls back to transform when cache file is corrupted", async () => {
+    const jsFile = path.join(TMP_DIR, "fallback.js");
+    fs.writeFileSync(jsFile, "export const y = 1;");
+
+    const plugin = sdAngularPlugin({
+      tsconfig: path.join(TMP_DIR, "tsconfig.json"),
+      dev: true,
+      linkerCacheDir: CACHE_DIR,
+    });
+    const load = getLoadHandler(plugin);
+
+    // First call to populate cache
+    await load(jsFile);
+
+    // Remove the cache file to simulate corruption/missing cache
+    const cacheFiles = fs.readdirSync(CACHE_DIR);
+    fs.rmSync(path.join(CACHE_DIR, cacheFiles[0]));
+
+    mockTransformFile.mockClear();
+    const result = await load(jsFile);
+    expect(mockTransformFile).toHaveBeenCalledOnce();
+    expect(result).toBe("transformed-code");
+  });
+
+  // Unit: Uint8Array result from transformFile is handled
+  it("handles Uint8Array result from transformFile", async () => {
+    const jsFile = path.join(TMP_DIR, "uint8.js");
+    fs.writeFileSync(jsFile, "export const z = 1;");
+
+    mockTransformFile.mockResolvedValue(new TextEncoder().encode("uint8-transformed") as unknown as string);
+
+    const plugin = sdAngularPlugin({
+      tsconfig: path.join(TMP_DIR, "tsconfig.json"),
+      dev: true,
+      linkerCacheDir: CACHE_DIR,
+    });
+    const load = getLoadHandler(plugin);
+
+    const result = await load(jsFile);
+    expect(result).toBe("uint8-transformed");
+
+    // Second call: cache hit should also return string
+    mockTransformFile.mockClear();
+    const result2 = await load(jsFile);
+    expect(mockTransformFile).not.toHaveBeenCalled();
+    expect(result2).toBe("uint8-transformed");
+  });
+
+  // Unit: non-.js file returns null (filter)
+  it("returns null for non-js files", async () => {
+    const plugin = sdAngularPlugin({
+      tsconfig: path.join(TMP_DIR, "tsconfig.json"),
+      dev: true,
+      linkerCacheDir: CACHE_DIR,
+    });
+    const load = getLoadHandler(plugin);
+
+    const result = await load(path.join(TMP_DIR, "data.json"));
+    expect(result).toBeNull();
+    expect(mockTransformFile).not.toHaveBeenCalled();
+  });
+});