$ npx vitest run tests/build.test.ts -t 고지는 각

 RUN  v5.0.4 /home/hermes/worktrees/find-word-v0.2.3

 ❯ tests/build.test.ts (21 tests | 8 failed | 13 skipped) 11103ms
   × street 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다 1389ms
   × mall 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다 1388ms
   × theater 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다 1377ms
   × department 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다 1360ms
   × market 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다 1376ms
   × subway 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다 1387ms
   × cafe 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다 1408ms
   × rain 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다 1416ms

⎯⎯⎯⎯⎯⎯⎯ Failed Tests 8 ⎯⎯⎯⎯⎯⎯⎯

 FAIL  tests/build.test.ts > street 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: street: Creator:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/38]⎯

 FAIL  tests/build.test.ts > street 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: street: Download:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[2/38]⎯

 FAIL  tests/build.test.ts > street 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: street: License:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[3/38]⎯

 FAIL  tests/build.test.ts > street 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: street: Output license:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[4/38]⎯

 FAIL  tests/build.test.ts > street 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: street: Changes:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[5/38]⎯

 FAIL  tests/build.test.ts > mall 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: mall: Creator:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[6/38]⎯

 FAIL  tests/build.test.ts > mall 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: mall: Download:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[7/38]⎯

 FAIL  tests/build.test.ts > mall 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: mall: License:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[8/38]⎯

 FAIL  tests/build.test.ts > mall 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: mall: Output license:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[9/38]⎯

 FAIL  tests/build.test.ts > mall 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: mall: Changes:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[10/38]⎯

 FAIL  tests/build.test.ts > theater 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: theater: Creator:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[11/38]⎯

 FAIL  tests/build.test.ts > theater 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: theater: Download:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[12/38]⎯

 FAIL  tests/build.test.ts > theater 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: theater: License:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[13/38]⎯

 FAIL  tests/build.test.ts > theater 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: theater: Output license:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[14/38]⎯

 FAIL  tests/build.test.ts > theater 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: theater: Changes:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[15/38]⎯

 FAIL  tests/build.test.ts > department 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: department: Creator:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[16/38]⎯

 FAIL  tests/build.test.ts > department 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: department: Download:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[17/38]⎯

 FAIL  tests/build.test.ts > department 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: department: License:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[18/38]⎯

 FAIL  tests/build.test.ts > department 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: department: Output license:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[19/38]⎯

 FAIL  tests/build.test.ts > department 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: department: Changes:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[20/38]⎯

 FAIL  tests/build.test.ts > market 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: market: Creator:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[21/38]⎯

 FAIL  tests/build.test.ts > market 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: market: Download:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[22/38]⎯

 FAIL  tests/build.test.ts > market 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: market: Output license:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[23/38]⎯

 FAIL  tests/build.test.ts > market 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: market: Changes:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[24/38]⎯

 FAIL  tests/build.test.ts > subway 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: subway: Creator:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[25/38]⎯

 FAIL  tests/build.test.ts > subway 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: subway: Download:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[26/38]⎯

 FAIL  tests/build.test.ts > subway 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: subway: Output license:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[27/38]⎯

 FAIL  tests/build.test.ts > subway 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: subway: Changes:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[28/38]⎯

 FAIL  tests/build.test.ts > cafe 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: cafe: Creator:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[29/38]⎯

 FAIL  tests/build.test.ts > cafe 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: cafe: Download:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[30/38]⎯

 FAIL  tests/build.test.ts > cafe 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: cafe: License:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[31/38]⎯

 FAIL  tests/build.test.ts > cafe 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: cafe: Output license:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[32/38]⎯

 FAIL  tests/build.test.ts > cafe 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: cafe: Changes:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[33/38]⎯

 FAIL  tests/build.test.ts > rain 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: rain: Creator:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[34/38]⎯

 FAIL  tests/build.test.ts > rain 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: rain: Download:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[35/38]⎯

 FAIL  tests/build.test.ts > rain 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: rain: License:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[36/38]⎯

 FAIL  tests/build.test.ts > rain 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: rain: Output license:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[37/38]⎯

 FAIL  tests/build.test.ts > rain 고지는 각 항목에 저작자·원문·다운로드·라이선스·파생권리·변경을 모두 포함한다
AssertionError: rain: Changes:: expected [Function verify] to throw an error
 ❯ tests/build.test.ts:172:48
    170|         modified[index] = modified[index]!.split("\n").filter((line) =…
    171|         writeNotice(modified.join("## "));
    172|         expect.soft(verify, `${id}: ${field}`).toThrow();
       |                                                ^
    173|       }
    174|     } finally { rmSync(temporary, { recursive: true, force: true }); }

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[38/38]⎯


 Test Files  1 failed (1)
      Tests  8 failed | 13 skipped (21)
   Start at  08:52:37
   Duration  11.45s (tests 99%, setup 1%)


EXIT_CODE=1